diff options
Diffstat (limited to 'lib/stdlib/test/qlc_SUITE.erl')
| -rw-r--r-- | lib/stdlib/test/qlc_SUITE.erl | 8179 |
1 files changed, 8179 insertions, 0 deletions
diff --git a/lib/stdlib/test/qlc_SUITE.erl b/lib/stdlib/test/qlc_SUITE.erl new file mode 100644 index 0000000000..ff11ebc6bf --- /dev/null +++ b/lib/stdlib/test/qlc_SUITE.erl @@ -0,0 +1,8179 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +%%%---------------------------------------------------------------- +%%% Purpose:Test Suite for the 'qlc' module. +%%%----------------------------------------------------------------- +-module(qlc_SUITE). + +-define(QLC, qlc). +-define(QLCs, "qlc"). + +%-define(debug, true). + +%% There are often many tests per testcase. Most tests are copied to a +%% module, a file. The file is compiled and the test run. Should the +%% test fail, the module file is not removed from ?privdir, but is +%% kept for inspection. The name of the file is +%% ?privdir/qlc_test_CASE.erl. +-define(TESTMODULE, qlc_test). +-define(TESTCASE, testcase_name). + +-ifdef(debug). +-define(line, put(line, ?LINE), ). +-define(config(X,Y), foo). +-define(datadir, ?QLCs ++ "_SUITE_data"). +-define(privdir, ?QLCs ++ "_SUITE_priv"). +-define(testcase, current_testcase). % don't know +-define(t, test_server). +-else. +-include("test_server.hrl"). +-define(datadir, ?config(data_dir, Config)). +-define(privdir, ?config(priv_dir, Config)). +-define(testcase, ?config(?TESTCASE, Config)). +-endif. + +-include_lib("stdlib/include/ms_transform.hrl"). + +-export([all/1, init_per_testcase/2, fin_per_testcase/2]). + +-export([parse_transform/1, + badarg/1, nested_qlc/1, unused_var/1, lc/1, fun_clauses/1, + filter_var/1, single/1, exported_var/1, generator_vars/1, + nomatch/1, errors/1, pattern/1, + + evaluation/1, + eval/1, cursor/1, fold/1, eval_unique/1, eval_cache/1, append/1, + evaluator/1, string_to_handle/1, table/1, process_dies/1, + sort/1, keysort/1, filesort/1, cache/1, cache_list/1, filter/1, + info/1, nested_info/1, lookup1/1, lookup2/1, lookup_rec/1, + indices/1, pre_fun/1, skip_filters/1, + + table_impls/1, + ets/1, dets/1, + + join/1, + join_option/1, join_filter/1, join_lookup/1, join_merge/1, + join_sort/1, join_complex/1, + + tickets/1, + otp_5644/1, otp_5195/1, otp_6038_bug/1, otp_6359/1, otp_6562/1, + otp_6590/1, otp_6673/1, otp_6964/1, otp_7114/1, otp_7238/1, + otp_7232/1, otp_7552/1, otp_6674/1, otp_7714/1, + + manpage/1, + + compat/1, + backward/1, forward/1]). + +%% Internal exports. +-export([bad_table_throw/1, bad_table_exit/1, default_table/1, bad_table/1, + bad_table_format/1, bad_table_format_arity/1, bad_table_traverse/1, + bad_table_post/1, bad_table_lookup/1, bad_table_max_lookup/1, + bad_table_info_arity/1, bad_table_info_fun_n_objects/1, + bad_table_info_fun_indices/1, bad_table_info_fun_keypos/1, + bad_table_key_equality/1]). +-export([evaluator_2/2]). +-export([prep_scratchdir/1, truncate_tmpfile/2, crash/2, crash_tmpfile/2]). +-export([etsc/2, etsc/3, create_ets/2, lookup_keys/1]). +-export([strip_qlc_call/1, join_info/1, join_info_count/1]). +-export([i/1, i/2, format_info/2]). + +-export([table_kill_parent/2, table_parent_throws/2, + table_parent_exits/2, table_bad_parent_fun/2]). +-export([table/2, table/3, stop_list/2, table_error/2, table_error/3, + table_lookup_error/1]). + +%% error_logger +-export([install_error_logger/0, uninstall_error_logger/0, + read_error_logger/0]). +-export([init/1, + handle_event/2, handle_call/2, handle_info/2, + terminate/2]). + +% Default timetrap timeout (set in init_per_testcase). +-define(default_timeout, ?t:minutes(5)). + +init_per_testcase(Case, Config) -> + ?line Dog = ?t:timetrap(?default_timeout), + [{?TESTCASE, Case}, {watchdog, Dog} | Config]. + +fin_per_testcase(_Case, _Config) -> + Dog = ?config(watchdog, _Config), + test_server:timetrap_cancel(Dog), + ok. + +all(suite) -> + [parse_transform, evaluation, table_impls, join, tickets, manpage, compat]. + +parse_transform(suite) -> + [badarg, nested_qlc, unused_var, lc, fun_clauses, filter_var, + single, exported_var, generator_vars, nomatch, errors, pattern]. + +badarg(doc) -> + "Badarg."; +badarg(suite) -> []; +badarg(Config) when is_list(Config) -> + Ts = + [{badarg, + <<"-import(qlc, [q/1, q/2]). + q(_, _, _) -> ok. + + badarg() -> + qlc:q(foo), + qlc:q(foo, cache_all), + qlc:q(foo, cache_all, extra), + q(bar), + q(bar, cache_all), + q(bar, cache_all, extra). + ">>, + [], + {errors,[{5,?QLC,not_a_query_list_comprehension}, + {6,?QLC,not_a_query_list_comprehension}, + {8,?QLC,not_a_query_list_comprehension}, + {9,?QLC,not_a_query_list_comprehension}], + []}}], + ?line [] = compile(Config, Ts), + ok. + +nested_qlc(doc) -> + "Nested qlc expressions."; +nested_qlc(suite) -> []; +nested_qlc(Config) when is_list(Config) -> + %% Nested QLC expressions. X is bound before the first one; Z and X + %% before the second one. + Ts = + [{nested_qlc1, + <<"nested_qlc() -> + X = 3, % X unused + Q = qlc:q([Y || + X <- % X shadowed + begin Z = 3, + qlc:q([Y || + Y <- [Z], + X <- [1,2,3], % X shadowed + X < Y]) + end, + Y <- + [y], + Y > X]), + [y, y] = qlc:e(Q), + ok. + ">>, + [warn_unused_vars], + {warnings,[{{2,15},erl_lint,{unused_var,'X'}}, + {{4,29},erl_lint,{shadowed_var,'X',generate}}, + {{8,49},erl_lint,{shadowed_var,'X',generate}}]}}, + + {nested_qlc2, + <<"nested_qlc() -> + H0 = qlc:append([a,b], [c,d]), + qlc:q([{X,Y} || + X <- H0, + Y <- qlc:q([{X,Y} || + X <- H0, % X shadowed + Y <- H0])]), + ok. + ">>, + [warn_unused_vars], + {warnings,[{{6,39},erl_lint,{shadowed_var,'X',generate}}]}} + ], + ?line [] = compile(Config, Ts), + ok. + +unused_var(doc) -> + "Unused variable with a name that should not be introduced."; +unused_var(suite) -> []; +unused_var(Config) when is_list(Config) -> + Ts = + [{unused_var, + <<"unused_var() -> + qlc:q([X || begin Y1 = 3, true end, % Y1 unused + Y <- [1,2,3], + X <- [a,b,c], + X < Y]). + ">>, + [warn_unused_vars], + {warnings,[{{2,33},erl_lint,{unused_var,'Y1'}}]}}], + ?line [] = compile(Config, Ts), + ok. + +lc(doc) -> + "Ordinary LC expression."; +lc(suite) -> []; +lc(Config) when is_list(Config) -> + Ts = + [{lc, + <<"lc() -> + [X || X <- [], X <- X]. % X shadowed + ">>, + [], + {warnings,[{{2,30},erl_lint,{shadowed_var,'X',generate}}]}}], + ?line [] = compile(Config, Ts), + ok. + +fun_clauses(doc) -> + "Fun with several clauses."; +fun_clauses(suite) -> []; +fun_clauses(Config) when is_list(Config) -> + Ts = + [{fun_clauses, + <<"fun_clauses() -> + {X,X1,X2} = {1,2,3}, + F = fun({X}) -> qlc:q([X || X <- X]); % X shadowed (fun, generate) + ([X]) -> qlc:q([X || X <- X]) % X shadowed (fun, generate) + end, + {F,X,X1,X2}. + ">>, + [], + {warnings,[{{3,22},erl_lint,{shadowed_var,'X','fun'}}, + {{3,41},erl_lint,{shadowed_var,'X',generate}}, + {{4,22},erl_lint,{shadowed_var,'X','fun'}}, + {{4,41},erl_lint,{shadowed_var,'X',generate}}]}}], + ?line [] = compile(Config, Ts), + ok. + +filter_var(doc) -> + "Variable introduced in filter."; +filter_var(suite) -> []; +filter_var(Config) when is_list(Config) -> + Ts = + [{filter_var, + <<"filter_var() -> + qlc:q([X || + Y <- [X || + X <- [1,2,3]], + begin X = Y, true end]). + ">>, + [], + []}, + + {unsafe_filter_var, + <<"unsafe_filter_var() -> + qlc:q([{X,V} || X <- [1,2], + case {a} of + {_} -> + true; + V -> + V + end]). + ">>, + [], + {errors,[{{2,25},erl_lint,{unsafe_var,'V',{'case',{3,19}}}}],[]}}], + ?line [] = compile(Config, Ts), + ok. + + +single(doc) -> + "Unused pattern variable."; +single(suite) -> []; +single(Config) when is_list(Config) -> + Ts = + [{single, + <<"single() -> + qlc:q([X || {X,Y} <- [{1,2}]]), % Y unused + qlc:q([[] || [] <- [[]]]). + ">>, + [warn_unused_vars], + {warnings,[{{2,30},erl_lint,{unused_var,'Y'}}]}}], + ?line [] = compile(Config, Ts), + ok. + +exported_var(doc) -> + "Exported variable in list expression (rhs of generator)."; +exported_var(suite) -> []; +exported_var(Config) when is_list(Config) -> + Ts = + [{exported_var, + <<"exported() -> + qlc:q([X || X <- begin + case foo:bar() of + 1 -> Z = a; + 2 -> Z = b + end, + [Z = 3, Z = 3] % Z exported (twice...) + end + ]). + ">>, + [warn_export_vars], + {warnings,[{{7,37},erl_lint,{exported_var,'Z',{'case',{3,36}}}}, + {{7,44},erl_lint,{exported_var,'Z',{'case',{3,36}}}}]}}], + ?line [] = compile(Config, Ts), + ok. + +generator_vars(doc) -> + "Errors for generator variable used in list expression."; +generator_vars(suite) -> []; +generator_vars(Config) when is_list(Config) -> + Ts = + [{generator_vars, + <<"generator_vars() -> + qlc:q([X || + Z <- [1,2], + X <- begin + case 1 of + 1 -> Z = a; % used_generator_variable + 2 -> Z = b % used_generator_variable + end, + [Z = 3, Z = 3] % used_generator_variable (2) + end + ]). + ">>, + [], + {errors,[{{6,41},?QLC,{used_generator_variable,'Z'}}, + {{7,41},?QLC,{used_generator_variable,'Z'}}, + {{9,33},?QLC,{used_generator_variable,'Z'}}, + {{9,40},?QLC,{used_generator_variable,'Z'}}], + []}}], + ?line [] = compile(Config, Ts), + ok. + +nomatch(doc) -> + "Unreachable clauses also found when compiling."; +nomatch(suite) -> []; +nomatch(Config) when is_list(Config) -> + Ts = + [{unreachable1, + <<"unreachable1() -> + qlc:q([X || X <- [1,2], + case X of + true -> false; + true -> true % clause cannot match + end]). + ">>, + [], + {warnings,[{5,v3_kernel,{nomatch_shadow,4}}]}}, + + {nomatch1, + <<"generator1() -> + qlc:q([3 || {3=4} <- []]). + ">>, + [], + {warnings,[{{2,27},qlc,nomatch_pattern}]}}, + + {nomatch2, + <<"nomatch() -> + etsc(fun(E) -> + Q = qlc:q([3 || {3=4} <- ets:table(E)]), + [] = qlc:eval(Q), + false = lookup_keys(Q) + end, [{1},{2}]). + ">>, + [], + {warnings,[{{3,33},qlc,nomatch_pattern}]}}, + + {nomatch3, + <<"nomatch() -> + etsc(fun(E) -> + Q = qlc:q([{A,B,C,D} || A=B={C=D}={_,_} <- + ets:table(E)]), + [] = qlc:eval(Q), + false = lookup_keys(Q) + end, [{1,2},{2,3}]). + ">>, + [], + {warnings,[{{3,52},qlc,nomatch_pattern}]}}, + + {nomatch4, + <<"nomatch() -> + etsc(fun(E) -> + Q = qlc:q([{X,Y} || {<<X>>} = {<<Y>>} <- + ets:table(E)]), + [] = qlc:eval(Q), + false = lookup_keys(Q) + end, [{<<34>>},{<<40>>}]). + ">>, + [], + {errors,[{{3,48},erl_lint,illegal_bin_pattern}],[]}}, + + {nomatch5, + <<"nomatch() -> + etsc(fun(E) -> + Q = qlc:q([t || {\"a\"++\"b\"} = {\"ac\"} <- + ets:table(E)]), + [t] = qlc:eval(Q), + [\"ab\"] = lookup_keys(Q) + end, [{\"ab\"}]). + ">>, + [], + {warnings,[{3,v3_core,nomatch}]}} + + ], + ?line [] = compile(Config, Ts), + ok. + + +errors(doc) -> + "Errors within qlc expressions also found when compiling."; +errors(suite) -> []; +errors(Config) when is_list(Config) -> + Ts = + [{errors1, + <<"errors1() -> + qlc:q([X || X <- A]). % A unbound + ">>, + [], + {errors,[{{2,33},erl_lint,{unbound_var,'A'}}],[]}}], + ?line [] = compile(Config, Ts), + ok. + +pattern(doc) -> + "Patterns."; +pattern(suite) -> []; +pattern(Config) when is_list(Config) -> + Ts = [ + <<"%% Records in patterns. No lookup. + L = [#a{k=#k{v=91}}], + H = qlc:q([Q || Q = #a{k=#k{v=91}} <- qlc_SUITE:table(L, 2, [])]), + {qlc,_,[{generate,_,{table,{call,_,_,_}}}], []} = i(H), + L = qlc:e(H), + {call, _, _q, [{lc,_,{var,_,'Q'}, + [{generate,_, + {match,_,_,_}, + {call,_,_,_}}]}]} + = i(H, {format,abstract_code})">>, + + <<"%% No matchspec since there is a binary in the pattern. + etsc(fun(E) -> + Q = qlc:q([A || {<<A:3/unit:8>>} <- ets:table(E)]), + [_] = qlc:eval(Q), + {qlc,_,[{generate,_,{table,_}}], []} = i(Q) + end, [{<<\"hej\">>}])">> + + ], + ?line run(Config, <<"-record(a, {k,v}). + -record(k, {t,v}).\n">>, Ts), + ok. + +evaluation(suite) -> + [eval, cursor, fold, eval_unique, eval_cache, append, evaluator, + string_to_handle, table, process_dies, sort, keysort, filesort, cache, + cache_list, filter, info, nested_info, lookup1, lookup2, lookup_rec, + indices, pre_fun, skip_filters]. + +eval(doc) -> + "eval/2"; +eval(suite) -> []; +eval(Config) when is_list(Config) -> + ScratchDir = filename:join([?privdir, "scratch","."]), + + Ts = [<<"{'EXIT',{badarg,_}} = (catch qlc:eval(not_a_qlc)), + H = qlc:q([X || X <- [1,2]]), + {'EXIT',{{unsupported_qlc_handle,{qlc_handle,foo}},_}}= + (catch qlc:e({qlc_handle,foo})), + {'EXIT',{badarg,_}} = (catch qlc:eval(H, [{unique_all,badarg}])), + {'EXIT',{badarg,_}} = + (catch qlc:eval(H, [{spawn_options,badarg}])), + {'EXIT',{badarg,_}} = + (catch qlc:eval(H, [{unique_all,true},{bad,arg}])), + {throw,t} = + (catch {any_term,qlc:e(qlc:q([X || X <- throw({throw,t})]))}), + M = qlc, + {'EXIT',{badarg,_}} = (catch M:q(bad))">>, + + [<<"Dir = \"">>,ScratchDir,<<"\", + qlc_SUITE:prep_scratchdir(Dir), + + E = ets:new(foo, []), + [true || I <- lists:seq(1, 50000), not ets:insert(E, {I, I})], + H = qlc:q([{X,Y} || Y <- [1,2], + X <- qlc:sort(ets:table(E),{tmpdir,Dir}), + qlc_SUITE:truncate_tmpfile(Dir, 0)]), + R = qlc:eval(H), + ets:delete(E), + {error,_,{bad_object,_}} = R, + \"the tempo\" ++ _ = lists:flatten(qlc:format_error(R))">>], + + [<<"Dir = \"">>,ScratchDir,<<"\", + qlc_SUITE:prep_scratchdir(Dir), + + E = ets:new(foo, []), + Bin = term_to_binary(lists:seq(1,20000)), + [true || I <- lists:seq(1, 10), not ets:insert(E, {I, I, Bin})], + H = qlc:q([{X,Y} || Y <- [1,2], + X <- qlc:sort(ets:table(E),{tmpdir,Dir}), + qlc_SUITE:crash_tmpfile(Dir, 5)]), + R = qlc:eval(H), + ets:delete(E), + {error,_,{bad_object,_}} = R">>], + + <<"E = ets:new(test, []), + H = qlc:q([{X,Y} || X <- qlc_SUITE:bad_table_throw(E), + Y <- ets:table(E)]), + R1 = (catch {any_term,qlc:eval(H, {unique_all,false})}), + R2 = (catch {any_term,qlc:eval(H, {unique_all,true})}), + ets:delete(E), + true = {throw,bad_pre_fun} == R1, + true = {throw,bad_pre_fun} == R2">>, + + <<"E = ets:new(test, []), + H = qlc:q([{X,Y} || X <- qlc_SUITE:bad_table_exit(E), + Y <- ets:table(E)]), + R1 = (catch qlc:eval(H, {unique_all,false})), + R2 = (catch qlc:eval(H, {unique_all,true})), + ets:delete(E), + {'EXIT',{bad_pre_fun,_}} = R1, + {'EXIT',{bad_pre_fun,_}} = R2">>, + + <<"Q = qlc:q([X || X <- [4,3,2,1,0,-1], begin 3/X > 0 end]), + {'EXIT',{badarith,_}} = (catch qlc:eval(Q, {unique_all,false})), + {'EXIT',{badarith,_}} = (catch qlc:eval(Q, {unique_all,true})) + ">>, + + <<"[1,2] = qlc:eval(qlc:q([X || X <- [1,2]])), + [1,2,3,4] = qlc:eval(qlc:append([1,2],[3,4])), + [1,2] = qlc:eval(qlc:sort([2,1])), + E = ets:new(foo, []), + ets:insert(E, [{1},{2}]), + [{1},{2}] = lists:sort(qlc:eval(ets:table(E))), + true = ets:delete(E)">>, + + <<"H = qlc:q([X || X <- [1,2], + begin F = fun() -> + qlc:e(qlc:q([Y || Y <- [1,2]])) end, + F() == (fun f/0)() end]), + [1,2] = qlc:e(H), + ok. + + f() -> [1,2]. + foo() -> bar">>, + + <<"C1_0_1 = [1,2], + %% The PT cannot rename C to C1_0_1; another name is chosen. + [1,2] = qlc:eval(qlc:q([C || C <- C1_0_1]))">>, + + <<"H = qlc:q([X || {X,X} <- [{1,a},{2,2},{b,b},{3,4}]]), + [2,b] = qlc:e(H), + H1 = qlc:q([3 || {X,X} <- [{1,a},{2,2},{b,b},{3,4}]]), + [3,3] = qlc:e(H1)">>, + + %% Just to cover a certain line in qlc.erl (avoids returning []) + <<"E = ets:new(foo, []), + Bin = term_to_binary(lists:seq(1,20000)), + [true || I <- lists:seq(1, 10), not ets:insert(E, {I, I, Bin})], + H = qlc:q([{X,Y} || Y <- [1,2], X <- qlc:sort(ets:table(E))]), + R = qlc:eval(H), + ets:delete(E), + 20 = length(R)">>, + + <<"H = qlc:q([{A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W} || + {A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W} <- + [{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w}]]), + [_] = qlc:e(H)">>, + + <<"H = qlc:q([Y || Y <- [1,2]], + {unique, begin [T] = qlc:e(qlc:q([X || X <- [true]], + cache)), + T end}), + [1,2] = qlc:e(H)">> + + ], + + ?line run(Config, Ts), + ok. + +cursor(doc) -> + "cursor/2"; +cursor(suite) -> []; +cursor(Config) when is_list(Config) -> + ScratchDir = filename:join([?privdir, "scratch","."]), + Ts = [<<"{'EXIT',{badarg,_}} = + (catch qlc:cursor(fun() -> not_a_cursor end)), + H0 = qlc:q([X || X <- throw({throw,t})]), + {throw,t} = (catch {any_term,qlc:cursor(H0)}), + H = qlc:q([X || X <- [1,2]]), + {'EXIT',{badarg,_}} = + (catch qlc:cursor(H,{spawn_options, [a|b]})), + {'EXIT',{badarg,_}} = + (catch qlc:cursor(H,{bad_option,true}))">>, + + <<"{'EXIT',{badarg,_}} = (catch qlc:delete_cursor(not_a_cursor))">>, + + [<<"Dir = \"">>,ScratchDir,<<"\", + qlc_SUITE:prep_scratchdir(Dir), % kludge + E = ets:new(foo, []), + [true || I <- lists:seq(1, 50000), not ets:insert(E, {I, I})], + H = qlc:q([{X,Y} || begin put('$qlc_tmpdir', true), true end, + Y <- [1,2], + X <- qlc:sort(ets:table(E),{tmpdir,Dir}), + qlc_SUITE:truncate_tmpfile(Dir, 0)]), + C = qlc:cursor(H), + R = qlc:next_answers(C, all_remaining), + qlc:delete_cursor(C), + erase('$qlc_tmpdir'), + ets:delete(E), + {error,_,{bad_object,_}} = R">>], + + <<"H1 = qlc:q([X || X <- [1,2]]), + C1 = qlc:cursor(H1), + [1,2] = qlc:next_answers(C1, all_remaining), + [] = qlc:next_answers(C1), + [] = qlc:next_answers(C1), + ok = qlc:delete_cursor(C1), + + H2 = qlc:append([1,2],[3,4]), + C2 = qlc:cursor(H2), + [1,2,3,4] = qlc:next_answers(C2, all_remaining), + ok = qlc:delete_cursor(C2), + + H3 = qlc:sort([2,1]), + C3 = qlc:cursor(H3), + [1,2] = qlc:next_answers(C3, all_remaining), + ok = qlc:delete_cursor(C3), + + E = ets:new(foo, []), + ets:insert(E, [{1},{2}]), + H4 = ets:table(E), + C4 = qlc:cursor(H4), + [{1},{2}] = lists:sort(qlc:next_answers(C4, all_remaining)), + ok = qlc:delete_cursor(C4), + true = ets:delete(E)">>, + + <<"H = qlc:q([{X,Y} || X <- [1,2], Y <- [a,b]]), + C = qlc:cursor(H, []), + [{1,a},{1,b}] = qlc:next_answers(C, 2), + [{2,a}] = qlc:next_answers(C, 1), + [{2,b}] = qlc:next_answers(C, all_remaining), + {'EXIT',{badarg,_}} = (catch qlc:next_answers(C, -1)), + P = self(), + Pid1 = spawn_link(fun() -> + {'EXIT',{not_cursor_owner,_}} = + (catch qlc:delete_cursor(C)), + P ! {self(), done} end), + Pid2 = spawn_link(fun() -> + {'EXIT',{not_cursor_owner,_}} = + (catch qlc:next_answers(C)), + P ! {self(), done} end), + receive {Pid1, done} -> ok end, + receive {Pid2, done} -> ok end, + ok = qlc:delete_cursor(C), + {'EXIT',{badarg,_}} = (catch qlc:next_answers(not_a_cursor)), + ok = qlc:delete_cursor(C)">>, + + <<"Q = qlc:q([X || X <- [1,2,1,2,1]]), + C1 = qlc:cursor(Q, [{unique_all,true}]), + [1,2] = qlc:next_answers(C1, all_remaining), + ok = qlc:delete_cursor(C1), + C2 = qlc:cursor(Q, [{unique_all,true}]), + [1,2] = qlc:next_answers(C2, all_remaining), + ok = qlc:delete_cursor(C2)">>, + + <<"Q = qlc:q([X || X <- [1,2,1,2,1]]), + C1 = qlc:cursor(Q, [{unique_all,true},{spawn_options, []}]), + [1,2] = qlc:next_answers(C1, all_remaining), + ok = qlc:delete_cursor(C1), + C2 = qlc:cursor(Q, [{unique_all,true},{spawn_options, default}]), + [1,2] = qlc:next_answers(C2, all_remaining), + ok = qlc:delete_cursor(C2)">>, + + <<"Q = qlc:q([X || X <- [1,2,1,2,1]]), + C1 = qlc:cursor(Q, [{unique_all,false},{spawn_options, []}]), + [1,2,1,2,1] = qlc:next_answers(C1, all_remaining), + ok = qlc:delete_cursor(C1), + C2 = qlc:cursor(Q, [{unique_all,false},{spawn_options, []}]), + [1,2,1,2,1] = qlc:next_answers(C2, all_remaining), + ok = qlc:delete_cursor(C2)">>, + + <<"Q = qlc:q([X || X <- [1,2,1,2,1]]), + C1 = qlc:cursor(Q, [{unique_all,false}]), + [1,2,1,2,1] = qlc:next_answers(C1, all_remaining), + ok = qlc:delete_cursor(C1), + C2 = qlc:cursor(Q, [{unique_all,false}]), + [1,2,1,2,1] = qlc:next_answers(C2, all_remaining), + ok = qlc:delete_cursor(C2)">> + + ], + ?line run(Config, Ts), + ok. + +fold(doc) -> + "fold/4"; +fold(suite) -> []; +fold(Config) when is_list(Config) -> + ScratchDir = filename:join([?privdir, "scratch","."]), + Ts = [<<"Q = qlc:q([X || X <- [1,2,1,2,1]]), + F = fun(Obj, A) -> A++[Obj] end, + {'EXIT',{badarg,_}} = (catch qlc:fold(F, [], Q, {bad,arg})), + {'EXIT',{badarg,_}} = (catch qlc:fold(F, [], badarg)), + {'EXIT',{badarg,_}} = + (catch qlc:fold(F, [], {spawn_options, [a|b]})), + H = qlc:q([X || X <- throw({throw,t})]), + {throw,t} = (catch {any_term,qlc:fold(F, [], H)}), + [1,2] = qlc:fold(F, [], Q, {unique_all,true}), + {'EXIT',{badarg,_}} = + (catch qlc:fold(F, [], Q, [{unique_all,bad}])), + [1,2,1,2,1] = + qlc:fold(F, [], Q, [{unique_all,false}])">>, + + [<<"Dir = \"">>,ScratchDir,<<"\", + qlc_SUITE:prep_scratchdir(Dir), + + E = ets:new(foo, []), + [true || I <- lists:seq(1, 50000), not ets:insert(E, {I, I})], + H = qlc:q([{X,Y} || Y <- [1,2], + X <- qlc:sort(ets:table(E),{tmpdir,Dir}), + qlc_SUITE:truncate_tmpfile(Dir, 0)]), + F = fun(Obj, A) -> A++[Obj] end, + R = qlc:fold(F, [], H), + ets:delete(E), + {error,_,{bad_object,_}} = R">>], + + <<"E = ets:new(test, []), + H = qlc:q([{X,Y} || X <- qlc_SUITE:bad_table_throw(E), + Y <- ets:table(E)]), + F = fun(Obj, A) -> A++[Obj] end, + R1 = (catch {any_term,qlc:fold(F, [], H, {unique_all,false})}), + R2 = (catch {any_term,qlc:fold(F, [], H, {unique_all,true})}), + ets:delete(E), + true = {throw,bad_pre_fun} == R1, + true = {throw,bad_pre_fun} == R2">>, + + <<"E = ets:new(test, []), + H = qlc:q([{X,Y} || X <- qlc_SUITE:bad_table_exit(E), + Y <- ets:table(E)]), + F = fun(Obj, A) -> A++[Obj] end, + R1 = (catch qlc:fold(F, [], H, {unique_all,false})), + R2 = (catch qlc:fold(F, [], H, {unique_all,true})), + ets:delete(E), + {'EXIT',{bad_pre_fun,_}} = R1, + {'EXIT',{bad_pre_fun,_}} = R2">>, + + <<"F = fun(Obj, A) -> A++[Obj] end, + Q = qlc:q([X || X <- [1,2,1,2,1], throw({throw,wrong})]), + {throw,wrong} = + (catch {any_term,qlc:fold(F, [], Q, {unique_all,true})}), + {throw,wrong} = + (catch {any_term,qlc:fold(F, [], Q)})">>, + + <<"F = fun(Obj, A) -> A++[Obj] end, + Q = qlc:q([X || X <- [4,3,2,1,0,-1], begin 3/X > 0 end]), + {'EXIT',{badarith,_}} = + (catch qlc:fold(F, [], Q, {unique_all,true})), + {'EXIT',{badarith,_}} = + (catch qlc:fold(F, [], Q, [{unique_all,false}])) + ">>, + + <<"F = fun(Obj, A) -> A++[Obj] end, + [1,2] = qlc:fold(F, [], qlc:q([X || X <- [1,2]])), + [1,2,3,4] = qlc:fold(F, [], qlc:append([1,2],[3,4])), + [1,2] = qlc:fold(F, [], qlc:sort([2,1])), + E = ets:new(foo, []), + ets:insert(E, [{1},{2}]), + [{1},{2}] = lists:sort(qlc:fold(F, [], ets:table(E))), + true = ets:delete(E)">>, + + <<"F = fun(_Obj, _A) -> throw({throw,fatal}) end, + Q = qlc:q([X || X <- [4,3,2]]), + {throw,fatal} = + (catch {any_term,qlc:fold(F, [], Q, {unique_all,true})}), + {throw,fatal} = + (catch {any_term,qlc:fold(F, [], Q, [{unique_all,false}])})">>, + + <<"G = fun(_Obj, _A, D) -> 17/D end, + F = fun(Obj, A) -> G(Obj, A, 0) end, + Q = qlc:q([X || X <- [4,3,2]]), + {'EXIT',{badarith,_}} = + (catch qlc:fold(F, [], Q, {unique_all,true})), + {'EXIT',{badarith,_}} = + (catch qlc:fold(F, [], Q, [{unique_all,false}])) + ">> + ], + ?line run(Config, Ts), + ok. + +eval_unique(doc) -> + "Test the unique_all option of eval."; +eval_unique(suite) -> []; +eval_unique(Config) when is_list(Config) -> + Ts = [<<"QLC1 = qlc:q([X || X <- qlc:append([[1,1,2], [1,2,3,2,3]])]), + [1,2,3] = qlc:eval(QLC1, {unique_all,true}), + QLC2 = qlc:q([X || X <- [1,2,1,2,1,2,1]]), + [1,2] = qlc:e(QLC2, {unique_all,true})">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([X || X <- qlc:append([ets:table(E), ets:table(E)])]), + R1 = qlc:e(H, {unique_all,false}), + R2 = qlc:e(H, {unique_all,true}), + ets:delete(E), + true = lists:sort(R1) == [{1,a},{1,a},{2,b},{2,b},{3,c},{3,c}], + true = lists:sort(R2) == [{1,a},{2,b},{3,c}] + ">>, + + <<"Q1 = qlc:q([{X,make_ref()} || X <- [1,2,1,2]]), + [_,_] = qlc:e(Q1, {unique_all,true}), + [_,_,_,_] = qlc:e(Q1, {unique_all,false}), + [_,_] = qlc:e(Q1, [{unique_all,true}]), + Q2 = qlc:q([{X,make_ref()} || X <- qlc:append([[1,2,1,2]])]), + [_,_] = qlc:e(Q2, {unique_all,true}), + [_,_,_,_] = qlc:e(Q2, {unique_all,false}), + [_,_] = qlc:e(Q2, [{unique_all,true}]) + ">>, + + <<"Q = qlc:q([{X,make_ref()} || X <- qlc:sort([1,2,1,2])]), + [_, _] = qlc:e(Q, {unique_all,true}), + Q1 = qlc:q([X || X <- [1,2,1,2]]), + Q2 = qlc:q([{X,make_ref()} || X <- qlc:sort(Q1)]), + [_, _] = qlc:e(Q2, {unique_all,true}) + ">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([X || X <- qlc:append([[1,2,1,2]])]), + [1,2,1,2] = qlc:e(H, {unique_all,false}), + [1,2] = qlc:e(H, {unique_all,true}), + ets:delete(E)">>, + + <<"E = ets:new(foo, [duplicate_bag]), + true = ets:insert(E, [{1,a},{1,a},{2,b},{3,c},{4,c},{4,d}]), + Q1 = qlc:q([{X,make_ref()} || {_, X} <- ets:table(E)]), + true = length(qlc:eval(Q1, {unique_all, true})) =:= 5, + Q2 = qlc:q([X || {_, X} <- ets:table(E)]), + true = length(qlc:eval(Q2, {unique_all, true})) =:= 4, + Q3 = qlc:q([element(2, X) || X <- ets:table(E)]), + true = length(qlc:eval(Q3, {unique_all, true})) =:= 4, + Q4 = qlc:q([1 || _X <- ets:table(E)]), + true = length(qlc:eval(Q4, {unique_all, true})) =:= 1, + true = ets:delete(E) + ">>, + + <<"Q1 = qlc:q([X || X <- qlc:append([[1], [2,1]])]), + Q2 = qlc:q([X || X <- qlc:append([[2,1], [2]])]), + Q3 = qlc:q([{X,Y} || X <- Q1, Y <- Q2]), + [{1,2},{1,1},{2,2},{2,1}] = qlc:e(Q3, {unique_all,true}), + Q4 = qlc:q([{X,Y,make_ref()} || X <- Q1, Y <- Q2]), + [{1,2,_},{1,1,_},{2,2,_},{2,1,_}] = qlc:e(Q4, {unique_all,true}) + ">>, + + <<"Q1 = qlc:q([X || X <- [1,2,1]]), + Q2 = qlc:q([X || X <- [2,1,2]]), + Q3 = qlc:q([{X,Y} || X <- Q1, Y <- Q2]), + [{1,2},{1,1},{2,2},{2,1}] = qlc:e(Q3,{unique_all,true}), + Q4 = qlc:q([{X,Y,make_ref()} || X <- Q1, Y <- Q2]), + [{1,2,_},{1,1,_},{2,2,_},{2,1,_}] = qlc:e(Q4, {unique_all,true}) + ">>, + + <<"Q1 = qlc:q([X || {X,_} <- [{1,a},{1,b}]]), + [1] = qlc:e(Q1, {unique_all, true}), + Q2 = qlc:q([a || _ <- [{1,a},{1,b}]]), + [a] = qlc:e(Q2, {unique_all, true}) + ">>, + + <<"Q = qlc:q([SQV || SQV <- qlc:q([X || X <- [1,2,1]],unique)], + unique), + {call,_,_,[{lc,_,{var,_,'X'},[{generate,_,{var,_,'X'},_}]},_]} = + qlc:info(Q, [{format,abstract_code},unique_all]), + [1,2] = qlc:e(Q)">>, + + <<"Q = qlc:q([X || X <- [1,2,1]]), + {call,_,_,[{lc,_,{var,_,'X'},[{generate,_,{var,_,'X'},_}]},_]} = + qlc:info(Q, [{format,abstract_code},unique_all]), + [1,2] = qlc:e(Q, unique_all)">>, + + <<"Q1 = qlc:sort([{1},{2},{3},{1}], [{unique,true}]), + Q = qlc:sort(Q1,[{unique,true}]), + {sort,{sort,{list,_},[{unique,true}]},[]} = i(Q)">> + + ], + ?line run(Config, Ts), + ok. + +eval_cache(doc) -> + "Test the cache_all and unique_all options of eval."; +eval_cache(suite) -> []; +eval_cache(Config) when is_list(Config) -> + Ts = [ + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H = qlc:q([X || Y <- [3,4], + ets:insert(E, {Y}), + X <- ets:table(E)]), % already unique, no cache... + {qlc, _, + [{generate, _, {qlc, _, + [{generate, _, {list, [3,4]}}], + [{unique,true}]}}, + _, + {generate, _, {table,_}}], + [{unique,true}]} = i(H, [cache_all, unique_all]), + [{1},{2},{3},{4}] = qlc:e(H, [cache_all, unique_all]), + ets:delete(E)">>, + + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H = qlc:q([X || Y <- [3,4], + ets:insert(E, {Y}), + X <- ets:table(E)]), % no cache... + {qlc, _, + [{generate, _,{list, [3,4]}}, + _, + {generate, _, {table,_}}], + []} = i(H, cache_all), + [{1},{2},{3},{1},{2},{3},{4}] = qlc:e(H, [cache_all]), + ets:delete(E)">>, + + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H = qlc:q([X || Y <- [3,4], + ets:insert(E, {Y}), + X <- qlc:q([X || X <- ets:table(E)], cache)]), + {qlc, _, + [{generate, _, {list, [3,4]}}, + _, + {generate, _, {qlc, _, + [{generate, _, {table,_}}], + [{cache,ets}]}}], + []} = i(H, cache_all), + [{1},{2},{3},{1},{2},{3}] = qlc:e(H, [cache_all]), + ets:delete(E)">>, + + <<"%% {cache_all,no} does not override {cache,true}. + E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H = qlc:q([X || Y <- [3,4], + ets:insert(E, {Y}), + X <- qlc:q([X || X <- ets:table(E)], cache)]), + {qlc, _, + [{generate, _, {list, [3,4]}}, + _, + {generate, _, {qlc, _, + [{generate, _, {table,_}}], + [{cache,ets}]}}], + []} = i(H, {cache_all,no}), + [{1},{2},{3},{1},{2},{3}] = qlc:e(H, [cache_all]), + ets:delete(E)">>, + + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H = qlc:q([X || Y <- [3,4], + ets:insert(E, {Y}), + X <- ets:table(E)]), + {qlc, _, + [{generate, _, {qlc, _, [{generate, _,{list, [3,4]}}], + [{unique,true}]}}, + _, + {generate, _,{table,_}}], + [{unique,true}]} = i(H, unique_all), + [{1},{2},{3},{4}] = qlc:e(H, [unique_all]), + ets:delete(E)">>, + + %% cache_all is ignored + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2},{0}]), + H = qlc:q([X || X <- qlc:sort(ets:table(E))]), + {sort,_Table,[]} = i(H, cache_all), + [{0},{1},{2}] = qlc:e(H, cache_all), + ets:delete(E)">>, + + <<"F = fun(Obj, A) -> A++[Obj] end, + E = ets:new(apa, [duplicate_bag]), + true = ets:insert(E, [{1,a},{2,b},{1,a}]), + Q = qlc:q([X || X <- ets:table(E)], cache), + {table, _} = i(Q, []), + R = qlc:fold(F, [], Q, []), + ets:delete(E), + true = [{1,a},{1,a},{2,b}] == lists:sort(R)">>, + + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2},{0}]), + H = qlc:q([X || X <- ets:table(E)], cache), + {table, _} = i(H, cache_all), + [{0},{1},{2}]= qlc:e(H, cache_all), + ets:delete(E)">>, + + <<"E = ets:new(foo, []), + true = ets:insert(E, [{1}, {2}]), + Q1 = qlc:q([{X} || X <- ets:table(E)]), + Q2 = qlc:q([{X,Y} || {X} <- Q1, {Y} <- Q1]), + {qlc, _, [{generate, _, {table, _}}, + {generate, _, {qlc, _, [{generate, _, {table, _}}], + [{cache,ets}]}}], + []} = i(Q2, cache_all), + [{{1},{1}},{{1},{2}},{{2},{1}},{{2},{2}}] = + lists:sort(qlc:e(Q2, cache_all)), + ets:delete(E)">>, + + <<"L1 = [1,2,3], + L2 = [4,5,6], + Q1 = qlc:append(L1, L2), + Q2 = qlc:q([{X} || X <- Q1]), + {qlc, _,[{generate, _,{append, [{list, L1}, {list, L2}]}}], []} = + i(Q2, [cache_all]), + [{1},{2},{3},{4},{5},{6}] = qlc:e(Q2, [cache_all])">>, + + <<"H = qlc:sort(qlc:q([1 || _ <- [a,b]])), + {sort, {qlc, _, [{generate, _, {qlc, _, [{generate, _, + {list, [a,b]}}], + [{unique,true}]}}], + [{unique,true}]}, + []} = i(H, unique_all), + [1] = qlc:e(H, unique_all)">> + + ], + ?line run(Config, Ts), + ok. + +append(doc) -> + "Test the append function."; +append(suite) -> []; +append(Config) when is_list(Config) -> + Ts = [<<"C = qlc:cursor(qlc:q([X || X <- [0,1,2,3], begin 10/X > 0.0 end])), + R = (catch qlc:next_answers(C)), + {'EXIT',{badarith,_}} = R">>, + + <<"C = qlc:cursor(qlc:q([X || X <- [0 | fun() -> exit(bad) end]])), + R = (catch qlc:next_answers(C)), + {'EXIT',bad} = R">>, + + <<"{'EXIT',{badarg,_}} = (catch qlc:append([a], a)), + {'EXIT',{badarg,_}} = (catch qlc:append([[a],a]))">>, + + <<"C = qlc:cursor(qlc:q([X || X <- [0,1,2,3], + begin throw({throw,wrong}), true end])), + {throw,wrong} = (catch {any_term,qlc:next_answers(C)})">>, + + <<"QLC = qlc:q([X || X <- [0,1,2,3], + begin throw({throw,wrong}), true end]), + {throw,wrong} = (catch {any_term,qlc:eval(QLC)}), + {throw,wrong} = + (catch {any_term,qlc:e(QLC, {unique_all,true})})">>, + + <<"H1 = qlc:q([X || X <- [1,2,3]]), + H2 = qlc:q([X || X <- [4,5,6]]), + R = qlc:e(qlc:q([X || X <- qlc:append([H1, H2])])), + true = R == [1,2,3,4,5,6]">>, + + <<"H1 = [1,2,3], + H2 = qlc:q([X || X <- [4,5,6]]), + R = qlc:e(qlc:q([X || X <- qlc:append(H1, H2)])), + true = R == [1,2,3,4,5,6]">>, + + <<"H1 = qlc:q([X || X <- [1,2,3]]), + H2 = qlc:q([X || X <- [4,5,6]]), + R = qlc:e(qlc:q([X || X <- qlc:append(qlc:e(H1), H2)])), + true = R == [1,2,3,4,5,6]">>, + + <<"H1 = qlc:q([X || X <- [1,2,3]]), + H2 = [4,5,6], + R = qlc:e(qlc:q([X || X <- qlc:append(H1, H2)])), + true = R == [1,2,3,4,5,6]">>, + + <<"H1 = qlc:q([X || X <- [1,2,3]]), + H2 = qlc:q([X || X <- [4,5,6]]), + R = qlc:e(qlc:q([X || X <- qlc:append([H1, H2, H1]), X < 5])), + true = R == [1,2,3,4,1,2,3]">>, + + <<"R = qlc:e(qlc:q([X || X <- qlc:append([lista(), anrop()])])), + true = R == [a,b,1,2], + ok. + + lista() -> + [a,b]. + + anrop() -> + qlc:q([X || X <- [1,2]]). + foo() -> bar">>, + + %% Used to work up to R11B. + % <<"apa = qlc:e(qlc:q([X || X <- qlc:append([[1,2,3], ugly()])])), + % ok. + % + % ugly() -> + % [a | apa]. + % foo() -> bar">>, + + + %% Maybe this one should fail. + <<"[a|b] = qlc:e(qlc:q([X || X <- qlc:append([[a|b]])])), + ok">>, + + <<"17 = qlc:e(qlc:q([X || X <- qlc:append([[1,2,3],ugly2()])])), + ok. + + ugly2() -> + [a | fun() -> 17 end]. + foo() -> bar">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([X || X <- qlc:append([ets:table(E), apa])]), + {'EXIT',{badarg,_}} = (catch qlc:e(H)), + false = ets:info(E, safe_fixed), + {'EXIT',{badarg,_}} = (catch qlc:e(H)), + false = ets:info(E, safe_fixed), + {'EXIT',{badarg,_}} = (catch qlc:cursor(H)), + false = ets:info(E, safe_fixed), + F = fun(Obj, A) -> A++[Obj] end, + {'EXIT',{badarg,_}} = (catch qlc:fold(F, [], H)), + false = ets:info(E, safe_fixed), + ets:delete(E)">>, + + <<"H1 = qlc:q([X || X <- [1,2,3]]), + H2 = qlc:q([X || X <- [a,b,c]]), + R = qlc:e(qlc:q([X || X <- qlc:append(H1,qlc:append(H1,H2))])), + true = R == [1,2,3,1,2,3,a,b,c]">>, + + <<"H = qlc:q([X || X <- qlc:append([],qlc:append([[], []]))]), + [] = qlc:e(H)">>, + + <<"Q1 = qlc:q([X || X <- [3,4,4]]), + Q2 = qlc:q([X || X <- qlc:sort(qlc:append([[1,2], Q1]))]), + [1,2,3,4,4] = qlc:e(Q2), + [1,2,3,4] = qlc:e(Q2, {unique_all,true})">>, + + <<"[] = qlc:e(qlc:q([X || X <- qlc:append([])]))">>, + + <<"Q1 = qlc:q([X || X <- [a,b]]), + Q2 = qlc:q([X || X <- [1,2]]), + Q3 = qlc:append([Q1, Q2, qlc:sort([2,1])]), + Q = qlc:q([X || X <- Q3]), + {append, [{list, [a,b]}, + {list, [1,2]}, + {sort,{list, [2,1]},[]}]} = i(Q), + [a,b,1,2,1,2] = qlc:e(Q)">> + + ], + ?line run(Config, Ts), + ok. + +evaluator(doc) -> + "Simple call from evaluator."; +evaluator(suite) -> []; +evaluator(Config) when is_list(Config) -> + ?line true = is_alive(), + evaluator_2(Config, []), + ?line {ok, Node} = start_node(qlc_SUITE_evaluator), + ?line ok = rpc:call(Node, ?MODULE, evaluator_2, [Config, [compiler]]), + ?line ?t:stop_node(Node), + ok. + +evaluator_2(Config, Apps) -> + ?line lists:foreach(fun(App) -> true = code:del_path(App) end, Apps), + FileName = filename:join(?privdir, "eval"), + ?line ok = file:write_file(FileName, + <<"H = qlc:q([X || X <- L]), + [1,2,3] = qlc:e(H).">>), + ?line Bs = erl_eval:add_binding('L', [1,2,3], erl_eval:new_bindings()), + ?line ok = file:eval(FileName, Bs), + + %% The error message is "handled" a bit too much... + %% (no trace of erl_lint left) + ?line ok = file:write_file(FileName, + <<"H = qlc:q([X || X <- L]), qlc:e(H).">>), + ?line {error,_} = file:eval(FileName), + + %% Ugly error message; badarg is caught by file.erl. + ?line ok = file:write_file(FileName, + <<"H = qlc:q([Z || {X,Y} <- [{a,2}], Z <- [Y]]), qlc:e(H).">>), + ?line {error,_} = file:eval(FileName), + + _ = file:delete(FileName), + ok. + +start_node(Name) -> + ?line PA = filename:dirname(code:which(?MODULE)), + ?t:start_node(Name, slave, [{args, "-pa " ++ PA}]). + +string_to_handle(doc) -> + "string_to_handle/1,2."; +string_to_handle(suite) -> []; +string_to_handle(Config) when is_list(Config) -> + ?line {'EXIT',{badarg,_}} = (catch qlc:string_to_handle(14)), + ?line {'EXIT',{badarg,_}} = + (catch qlc:string_to_handle("[X || X <- [a].", unique_all)), + ?line R1 = {error, _, {_,erl_scan,_}} = qlc:string_to_handle("'"), + ?line "1: unterminated " ++ _ = lists:flatten(qlc:format_error(R1)), + ?line {error, _, {_,erl_parse,_}} = qlc:string_to_handle("foo"), + ?line {'EXIT',{badarg,_}} = (catch qlc:string_to_handle("foo, bar.")), + ?line R3 = {error, _, {_,?QLC,not_a_query_list_comprehension}} = + qlc:string_to_handle("bad."), + ?line "1: argument is not" ++ _ = lists:flatten(qlc:format_error(R3)), + ?line R4 = {error, _, {_,?QLC,{used_generator_variable,'Y'}}} = + qlc:string_to_handle("[X || begin Y = [1,2], true end, X <- Y]."), + ?line "1: generated variable 'Y'" ++ _ = + lists:flatten(qlc:format_error(R4)), + ?line {error, _, {_,erl_lint,_}} = qlc:string_to_handle("[X || X <- A]."), + ?line H1 = qlc:string_to_handle("[X || X <- [1,2]]."), + ?line [1,2] = qlc:e(H1), + ?line H2 = qlc:string_to_handle("[X || X <- qlc:append([a,b]," + "qlc:e(qlc:q([X || X <- [c,d,e]])))]."), + ?line [a,b,c,d,e] = qlc:e(H2), + %% The generated fun has many arguments (erl_eval has a maximum of 20). + ?line H3 = qlc:string_to_handle( + "[{A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W} ||" + " {A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W} <- []]."), + ?line [] = qlc:e(H3), + ?line Bs1 = erl_eval:add_binding('L', [1,2,3], erl_eval:new_bindings()), + ?line H4 = qlc:string_to_handle("[X || X <- L].", [], Bs1), + ?line [1,2,3] = qlc:e(H4), + ?line H5 = qlc:string_to_handle("[X || X <- [1,2,1,2]].", [unique, cache]), + ?line [1,2] = qlc:e(H5), + + ?line Ets = ets:new(test, []), + ?line true = ets:insert(Ets, [{1}]), + ?line Bs2 = erl_eval:add_binding('E', Ets, erl_eval:new_bindings()), + ?line Q = "[X || {X} <- ets:table(E)].", + ?line [1] = qlc:e(qlc:string_to_handle(Q, [], Bs2)), + ?line [1] = qlc:e(qlc:string_to_handle(Q, {max_lookup,1000}, Bs2)), + ?line [1] = qlc:e(qlc:string_to_handle(Q, {max_lookup,infinity}, Bs2)), + ?line {'EXIT',{badarg,_}} = + (catch qlc:string_to_handle(Q, {max_lookup,-1}, Bs2)), + ?line {'EXIT', {no_lookup_to_carry_out, _}} = + (catch qlc:e(qlc:string_to_handle(Q, {lookup,true}, Bs2))), + ?line ets:delete(Ets), + ok. + +table(doc) -> + "table"; +table(suite) -> []; +table(Config) when is_list(Config) -> + dets:start(), + Ts = [ + <<"E = ets:new(test, []), + {'EXIT',{badarg,_}} = + (catch qlc:e(qlc:q([X || X <- ets:table(E, [badarg])]))), + [] = qlc:e(qlc:q([X || X <- ets:table(E)])), + ets:delete(E)">>, + + <<"{'EXIT',{badarg,_}} = (catch qlc:table(not_a_fun, []))">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([{X,Y} || X <- ets:table(E), Y <- ets:table(E)]), + R = qlc:e(H), + ets:delete(E), + [{{1,a},{1,a}},{{1,a},{2,b}},{{1,a},{3,c}}, + {{2,b},{1,a}},{{2,b},{2,b}},{{2,b},{3,c}}, + + {{3,c},{1,a}},{{3,c},{2,b}},{{3,c},{3,c}}] = lists:sort(R)">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([X || X <- qlc:append([ets:table(E), [a,b,c], + ets:table(E)])]), + R = qlc:e(H), + ets:delete(E), + [a,b,c,{1,a},{1,a},{2,b},{2,b},{3,c},{3,c}] = lists:sort(R)">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + false = ets:info(E, safe_fixed), + H = qlc:q([{X,Y} || X <- ets:table(E, {n_objects, default}), + Y <- ets:table(E, {n_objects, 2}), + false =/= ets:info(E, safe_fixed), + throw({throw,apa})]), + {throw,apa} = (catch {any_term,qlc:e(H)}), + false = ets:info(E, safe_fixed), + ets:delete(E)">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + false = ets:info(E, safe_fixed), + H = qlc:q([{X,Y} || X <- ets:table(E), Y <- ets:table(E), + false =/= ets:info(E, safe_fixed), exit(apa)]), + {'EXIT',apa} = (catch {any_term,qlc:e(H)}), + false = ets:info(E, safe_fixed), + ets:delete(E)">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([{X,Y} || X <- qlc_SUITE:bad_table_throw(E), + Y <- ets:table(E)]), + R = (catch {any_term,qlc:cursor(H)}), + false = ets:info(E, safe_fixed), + ets:delete(E), + {throw,bad_pre_fun} = R">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([{X,Y} || X <- qlc_SUITE:bad_table_exit(E), + Y <- ets:table(E)]), + R = (catch {any_term,qlc:cursor(H)}), + false = ets:info(E, safe_fixed), + ets:delete(E), + {'EXIT',{bad_pre_fun,_}} = R">>, + + <<"E = ets:new(test, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([X || X <- qlc_SUITE:default_table(E)]), + R = qlc:e(H), + ets:delete(E), + [{1,a},{2,b},{3,c}] = R">>, + + <<"E = ets:new(test, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([X || X <- qlc_SUITE:bad_table(E)]), + {'EXIT', {badarg, _}} = (catch qlc:e(H)), + ets:delete(E)">>, + + %% The info tag num_of_objects is currently not used. +% <<"E = ets:new(test, [ordered_set]), +% true = ets:insert(E, [{1,a},{2,b},{3,c}]), +% H = qlc:q([X || X <- qlc_SUITE:bad_table_info_fun_n_objects(E)]), +% {'EXIT', finito} = (catch {any_term,qlc:e(H)}), +% ets:delete(E)">>, + + <<"E = ets:new(test, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([Y || {X,Y} <- qlc_SUITE:bad_table_info_fun_indices(E), + X =:= a]), + %% This is due to lookup. If the table were traversed there + %% would be no failure. + {throw, apa} = (catch {any_term,qlc:e(H)}), + ets:delete(E)">>, + + <<"E = ets:new(test, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + H = qlc:q([Y || {X,Y} <- qlc_SUITE:bad_table_info_fun_keypos(E), + X =:= a]), + {'EXIT',{keypos,_}} = (catch {any_term,qlc:info(H)}), + {'EXIT',{keypos,_}} = (catch {any_term,qlc:e(H)}), + ets:delete(E)">>, + + begin + MS = ets:fun2ms(fun(X) when element(1, X) > 1 -> X end), + [<<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + MS = ">>, io_lib:format("~w", [MS]), <<", + H = qlc:q([{X,Y} || X <- ets:table(E,{traverse,{select, MS}}), + Y <- ets:table(E)]), + R = qlc:e(H), + ets:delete(E), + [{{2,b},{1,a}},{{2,b},{2,b}},{{2,b},{3,c}}, + {{3,c},{1,a}},{{3,c},{2,b}},{{3,c},{3,c}}] = lists:sort(R)">>] + end, + + begin % a short table + MS = ets:fun2ms(fun(X) when element(1, X) > 1 -> X end), + [<<"E = ets:new(test, []), + true = ets:insert(E, [{0,b}]), + MS = ">>, io_lib:format("~w", [MS]), <<", + H1 = qlc:q([X || X <- ets:table(E)]), + R1 = qlc:e(H1), + H2 = qlc:q([X || X <- ets:table(E, {traverse, {select, MS}})]), + R2 = qlc:e(H2), + ets:delete(E), + [_] = R1, + [] = R2">>] + end, + + begin + File = filename:join(?privdir, "detsfile"), + _ = file:delete(File), + [<<"{ok, Tab} = dets:open_file(apa, [{file,\"">>, File, <<"\"}, + {type,bag}]), + ok = dets:insert(Tab, [{1,a},{1,b}]), + R = qlc:e(qlc:q([X || X <- dets:table(Tab)])), + dets:close(Tab), + file:delete(\"">>, File, <<"\"), + R">>] + end, + + %% [T || P <- Table, F] turned into a match spec. + <<"E = ets:new(apa, [duplicate_bag]), + true = ets:insert(E, [{1,a},{2,b},{3,c},{4,d}]), + QH = qlc:q([X || {X,_} <- ets:table(E), X > 2], unique), + {qlc, _, [{generate, _, {table, _}}], [{unique,true}]} = i(QH), + [3,4] = lists:sort(qlc:e(QH)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_format(E)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_format_arity(E)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_info_arity(E)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_traverse(E)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_post(E)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_max_lookup(E)), + ets:delete(E)">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = (catch qlc_SUITE:bad_table_lookup(E)), + ets:delete(E)">>, + + <<"L = [{1,a},{2,b},{3,c}], + QH = qlc:q([element(2, X) || X <- qlc_SUITE:table(L, [2]), + (element(1, X) =:= 1) + or (2 =:= element(1, X))]), + [a,b] = lists:sort(qlc:e(QH))">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B} || {A,B} <- + qlc:q([{B,A} || {A,B} <- ets:table(E), + (A =:= 1) or (A =:= 2), + math:sqrt(B) < A])]), + [{2,2}] = qlc:eval(Q), + [1,2] = lookup_keys(Q) + end, [{1,1},{2,2}])">> + ], + ?line run(Config, Ts), + + Ts2 = [ + %% [T || P <- Table, F] turned into a match spec. Records needed. + <<"E = ets:new(foo, [bag]), + ets:insert(E, [{a,1,2},#a{b=3,c=4},{a,3}]), + QH = qlc:q([X || X <- ets:table(E), is_record(X, a)]), + {list,{table,_}, _} = i(QH), + [{a,1,2},{a,3,4}] = lists:sort(qlc:eval(QH)), + ets:delete(E)">> + ], + ?line run(Config, <<"-record(a, {b,c}).\n">>, Ts2), + + ok. + +process_dies(doc) -> + "Caller or cursor process dies."; +process_dies(suite) -> []; +process_dies(Config) when is_list(Config) -> + Ts = [ + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + false = ets:info(E, safe_fixed), + Parent = self(), + F = fun() -> + H = qlc:q([X || X <- ets:table(E)]), + qlc:cursor(H), + Parent ! {self(),ok} + end, + Pid = spawn_link(F), + receive {Pid,ok} -> ok end, + timer:sleep(10), + false = ets:info(E, safe_fixed), + ets:delete(E)">>, + + <<"%% This is not nice. The cursor's monitor kicks in. + E = ets:new(test, []), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + false = ets:info(E, safe_fixed), + Parent = self(), + F = fun() -> + H = qlc:q([X || begin + process_flag(trap_exit, false), + {links, [Pid]} = + process_info(self(), links), + unlink(Pid), + timer:sleep(1), + {links, []} = + process_info(self(), links), + true + end, + X <- ets:table(E)]), + C = qlc:cursor(H), + qlc:next_answers(C), + Parent ! {self(),ok} + end, + Pid = spawn_link(F), + receive {Pid,ok} -> ok end, + timer:sleep(10), + false = ets:info(E, safe_fixed), + ets:delete(E)">>, + + <<"H = qlc:q([X || X <- [1,2]]), + {qlc_cursor, Term} = C = qlc:cursor(H), + PF = process_flag(trap_exit, true), + F = fun(T) -> not is_pid(T) end, + [Pid|_] = lists:dropwhile(F, tuple_to_list(Term)), + exit(Pid, kill), + timer:sleep(1), + {'EXIT', {{qlc_cursor_pid_no_longer_exists, Pid}, _}} = + (catch qlc:next_answers(C)), + process_flag(trap_exit, PF)">>, + <<"H = qlc:q([X || begin process_flag(trap_exit, true), true end, + X <- [1,2]]), + {qlc_cursor, Term} = C = qlc:cursor(H), + PF = process_flag(trap_exit, true), + F = fun(T) -> not is_pid(T) end, + [Pid|_] = lists:dropwhile(F, tuple_to_list(Term)), + [1] = qlc:next_answers(C, 1), + exit(Pid, stop), + timer:sleep(1), + {'EXIT', {{qlc_cursor_pid_no_longer_exists, Pid}, _}} = + (catch qlc:next_answers(C)), + process_flag(trap_exit, PF)">>, + <<"%% This is not nice. No cleanup is done... + H = qlc:q([X || begin process_flag(trap_exit, false), true end, + X <- [1,2]]), + {qlc_cursor, Term} = C = qlc:cursor(H), + PF = process_flag(trap_exit, true), + F = fun(T) -> not is_pid(T) end, + [Pid|_] = lists:dropwhile(F, tuple_to_list(Term)), + [1] = qlc:next_answers(C, 1), + exit(Pid, stop), + timer:sleep(1), + {'EXIT', {{qlc_cursor_pid_no_longer_exists, Pid}, _}} = + (catch qlc:next_answers(C)), + process_flag(trap_exit, PF)">>, + + <<"PF = process_flag(trap_exit, true), + E = ets:new(test, []), + %% Hard kill. No cleanup will be done. + H = qlc:q([X || begin exit(self(), kill), true end, + X <- ets:table(E)]), + C = qlc:cursor(H), + {'EXIT', {{qlc_cursor_pid_no_longer_exists, _}, _}} = + (catch qlc:next_answers(C)), + false = ets:info(E, safe_fixed), % - but Ets cleans up anyway. + true = ets:delete(E), + process_flag(trap_exit, PF)">>, + + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a}]), + %% The signal is caught by trap_exit. No process dies... + H = qlc:q([X || begin exit(self(), normal), true end, + X <- ets:table(E)]), + C = qlc:cursor(H, {spawn_options, []}), + [{1,a}] = qlc:next_answers(C), + qlc:delete_cursor(C), + false = ets:info(E, safe_fixed), + true = ets:delete(E)">>, + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a}]), + %% The same as last example. + H = qlc:q([X || begin + process_flag(trap_exit, true), + exit(self(), normal), true + end, + X <- ets:table(E)]), + C = qlc:cursor(H, {spawn_options, []}), + [{1,a}] = qlc:next_answers(C), + qlc:delete_cursor(C), + false = ets:info(E, safe_fixed), + true = ets:delete(E), ok">>, + <<"E = ets:new(test, []), + true = ets:insert(E, [{1,a}]), + H = qlc:q([X || X <- ets:table(E)]), + SpawnOpts = [link, monitor], % monitor is ignored + {qlc_cursor, Term} = C = qlc:cursor(H, {spawn_options, SpawnOpts}), + F = fun(T) -> not is_pid(T) end, + [Pid|_] = lists:dropwhile(F, tuple_to_list(Term)), + Me = self(), + qlc_SUITE:install_error_logger(), + Tuple = {this, tuple, is, writton, onto, the, error_logger}, + SP = spawn(fun() -> + Pid ! Tuple, + Me ! {self(), done} + end), + receive {SP, done} -> ok end, + [{1,a}] = qlc:next_answers(C), + qlc:delete_cursor(C), + {error, _Pid, Tuple} = qlc_SUITE:read_error_logger(), + qlc_SUITE:uninstall_error_logger(), + false = ets:info(E, safe_fixed), + true = ets:delete(E), ok">> + + ], + ?line run(Config, Ts), + ok. + +sort(doc) -> + "The sort option."; +sort(suite) -> []; +sort(Config) when is_list(Config) -> + Ts = [ + <<"H = qlc:q([X || X <- qlc:sort([1,2,3,2], {unique,true})]), + [1,2,3] = qlc:e(H), + C1 = qlc:cursor(H), + [1,2,3] = qlc:next_answers(C1, all_remaining), + qlc:delete_cursor(C1)">>, + + <<"H = qlc:q([{X,Y} || X <- qlc:sort(qlc:q([X || X <- [1,2,3,2]]), + {unique,true}), + Y <- [a,b]]), + [{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}] = qlc:e(H), + C = qlc:cursor(H), + [{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}] = + qlc:next_answers(C, all_remaining), + qlc:delete_cursor(C)">>, + + <<"H = qlc:q([X || X <- qlc:sort(qlc:q([X || X <- apa]))]), + {'EXIT',{badarg,_}} = (catch qlc:e(H))">>, + + %% An example with a side effect. The result may vary... + <<"E = ets:new(test, [duplicate_bag]), + true = ets:insert(E, [{1,17},{1,a}]), + H_1 = qlc:q([X || X <- ets:table(E)]), + H = qlc:q([X || X <- [1,2,3], ets:insert(E, {1,-X}), + {_,Y} <- H_1, + X > Y]), + true = lists:sort(qlc:e(H)) == [1,2,2,3,3,3], + true = ets:delete(E)">>, + + <<"E = ets:new(test, [duplicate_bag]), + true = ets:insert(E, [{1,17}]), + H_1 = qlc:q([X || X <- qlc:sort(ets:tab2list(E))]), + %% Note: side effect in filter! + H = qlc:q([X || X <- [1,2,3], ets:insert(E, {1,-X}), + {_,Y} <- H_1, X > Y]), + [] = qlc:e(H), + true = ets:delete(E)">>, + + <<"H = qlc:q([X || X <- qlc:sort([1,2,3], {fopp,la})]), + {'EXIT',{badarg,_}} = (catch qlc:e(H)), + {'EXIT',{badarg,_}} = (catch qlc:cursor(H)), + F = fun(Obj, A) -> A++[Obj] end, + {'EXIT',{badarg,_}} = (catch qlc:fold(F, [], H))">>, + + <<"Q1 = qlc:q([X || X <- [1,2]]), + AL = [Q1, [1,2,3]], + Q2 = qlc:q([X || X <- qlc:sort(qlc:append(AL))]), + [1,1,2,2,3] = qlc:e(Q2)">>, + + <<"H = qlc:q([{X,Y} || X <- qlc:sort(qlc:q([X || X <- [1,2,3,2]]), + {unique,true}), + Y <- [a,b]]), + {qlc, _, + [{generate, _, {sort, {qlc, _, [{generate, _, {list, [1,2,3,2]}}], + [{unique,true}]}, + []}}, + {generate, _, {qlc, _, [{generate, _, {list, [a,b]}}], + [{unique,true}]}}], + [{unique,true}]} = i(H, unique_all), + [{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}] = qlc:e(H, unique_all)">>, + + <<"L = [1,2,1,3,4,3,1], + true = lists:sort(L) == qlc:e(qlc:q([X || X <- qlc:sort(L)])), + true = lists:usort(L) == + qlc:e(qlc:q([X || X <- qlc:sort(L, {unique,true})])), + true = lists:reverse(lists:sort(L)) == + qlc:e(qlc:q([X || X <- qlc:sort(L, {order, descending})])), + true = lists:reverse(lists:usort(L)) == + qlc:e(qlc:q([X || X <- qlc:sort(L, [{order, descending}, + {unique, true}])])), + CF = fun(X, Y) -> X =< Y end, + true = lists:sort(L) == + qlc:e(qlc:q([X || X <- qlc:sort(L, {order, CF})])), + true = lists:usort(L) == + qlc:e(qlc:q([X || X <- qlc:sort(L, [{order, CF}, + {unique, true}])]))">>, + + <<"E = ets:new(foo, []), + [true || I <- lists:seq(1, 50000), not ets:insert(E, {I, I})], + H = qlc:q([{X,Y} || X <- [a,b], Y <- qlc:sort(ets:table(E))]), + 100000 = length(qlc:e(H)), + ets:delete(E)">>, + + begin + TmpDir = ?privdir, + [<<"TE = process_flag(trap_exit, true), + E = ets:new(foo, []), + [true || I <- lists:seq(1, 50000), not ets:insert(E, {I, I})], + Ports = erlang:ports(), + H = qlc:q([{X,Y} || X <- [a,b], + begin + [P] = erlang:ports() -- Ports, + exit(P, port_exit), + true + end, + Y <- qlc:sort(ets:table(E), + [{tmpdir,\"">>, + TmpDir, <<"\"}])]), + {error, qlc, {file_error, _, _}} = (catch qlc:e(H)), + receive {'EXIT', _, port_exit} -> ok end, + ets:delete(E), + process_flag(trap_exit, TE)">>] + end + + ], + ?line run(Config, Ts), + ok. + +keysort(doc) -> + "The sort option."; +keysort(suite) -> []; +keysort(Config) when is_list(Config) -> + + Ts = [ + <<"OF = fun(X, Y) -> X =< Y end, + F = fun(Obj, A) -> A++[Obj] end, + H = qlc:q([X || X <- qlc:keysort(1, [{2,a},{1,b}], {order,OF})]), + {'EXIT',{{badarg,order},_}} = (catch qlc:e(H)), + {'EXIT',{{badarg,order},_}} = (catch qlc:fold(F, [], H)), + {'EXIT',{{badarg,order},_}} = (catch qlc:cursor(H))">>, + + <<"E = create_ets(1, 2), + H = qlc:q([X || X <- qlc:keysort([1], ets:table(E), + [{size,1},{tmpdir,\"/a/b/c\"}])]), + H1 = qlc:q([X || {X,_} <- qlc:e(H), X < 4]), + {error,_,{file_error,_,_}} = qlc:info(H1), + {error,_,{file_error,_,_}} = qlc:e(H1), + ets:delete(E)">>, + + <<"L = [{1,a},{2,b},{3,c},{2,b}], + H = qlc:q([{X,Y} || {X,_} <- qlc:keysort(1, qlc:q([X || X <- L]), + {unique,true}), + Y <- [a,b]]), + [{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}] = qlc:e(H), + C = qlc:cursor(H), + [{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}] = + qlc:next_answers(C, all_remaining), + qlc:delete_cursor(C)">>, + + <<"H1 = qlc:q([X || X <- qlc:keysort(0, [])]), + {'EXIT',{badarg,_}} = (catch qlc:e(H1)), + H2 = qlc:q([X || X <- qlc:keysort(1, [], {bad,arg})]), + {'EXIT',{badarg,_}} = (catch qlc:e(H2)), + H3 = qlc:q([X || X <- qlc:keysort([], [])]), + {'EXIT',{badarg,_}} = (catch qlc:e(H3))">>, + + <<"H = qlc:q([X || X <- qlc:keysort(1, [{1,a},{2,b}], + [{order,descending}, + {compressed,true}])]), + [{2,b},{1,a}] = qlc:e(H), + H2 = qlc:q([X || X <- qlc:keysort(1, [{1},{2}], compressed)]), + {'EXIT', {badarg, _}} = (catch qlc:e(H2))">>, + + <<"H = qlc:q([X || X <- qlc:keysort(1, [{1,a},{2,b}], {compressed,false})]), + [{1,a},{2,b}] = qlc:e(H)">>, + + <<"E = create_ets(1, 2), + H = qlc:q([X || X <- qlc:keysort([1], ets:table(E), + [{size,1},{tmpdir,\"/a/b/c\"}])]), + F = fun(Obj, A) -> A++[Obj] end, + {error,_,{file_error,_,_}} = qlc:e(H), + \" \\\"no such\" ++ _ = lists:dropwhile(fun(A) -> A =/= $\s end, + lists:flatten(qlc:format_error(qlc:e(H)))), + {error,_,{file_error,_,_}} = qlc:e(H, {unique_all,true}), + {error,_,{file_error,_,_}} = qlc:cursor(H), + {error,_,{file_error,_,_}} = qlc:cursor(H, {unique_all,true}), + {error,_,{file_error,_,_}} = qlc:cursor(H, {spawn_options, []}), + {error,_,{file_error,_,_}} = qlc:cursor(H, {spawn_options,default}), + {error,_,{file_error,_,_}} = + qlc:cursor(H, [{unique_all,true},{spawn_options, []}]), + {error,_,{file_error,_,_}} = qlc:fold(F, [], H), + {error,_,{file_error,_,_}} = qlc:fold(F, [],H, {unique_all,true}), + ets:delete(E)">>, + + <<"L = [{1,b,a},{1,b,b},{1,a,a}], + H = qlc:q([X || X <- qlc:keysort([4,1], L)]), + {error,_,bad_object} = qlc:e(H), + \"the keys\" ++ _ = qlc:format_error(qlc:e(H))">>, + + begin + File = filename:join(?privdir, "afile"), + ok = file:write_file(File, <<>>), + [<<"H = qlc:q([X || X <- qlc:keysort([1], [{1},{2},{1}], + [{tmpdir,\"">>, File, <<"\"}, + {size,1}])]), + {error,_,{file_error,_,_}} = qlc:e(H), + file:delete(\"">>, File, <<"\")">>] + end, + + <<"H0 = qlc:q([X || X <- [1,2,3]]), + H = qlc:q([X || X <- qlc:sort(H0,{tmpdir,\".\"})]), + [1,2,3] = qlc:e(H)">>, + + %% The global option 'tmpdir' takes precedence. + begin + PrivDir = ?privdir, + [<<"L = [{1,a},{2,b}], + H = qlc:q([X || X <- qlc:keysort([1], L, {tmpdir,\"/a/b/c\"})]), + H1 = qlc:q([X || X <- H, X > 3]), + Dir = \"">>, PrivDir, <<"\", + Options = [{tmpdir, Dir}], + {qlc,_,[{generate,_,{keysort,{list,L},[1],[{tmpdir,Dir}]}},_],[]} = + i(H1, Options), + [{1,a},{2,b}] = qlc:e(H1, Options)">>] % no check of "/a/b/c" + end, + + <<"L = [{2,c},{1,b},{1,a},{3,a},{1,c},{2,b}], + true = lists:sort(L) == + qlc:e(qlc:q([X || X <- qlc:keysort([1,2], L)]))">>, + + <<"L = [{1,b},{2,c},{1,a},{3,e},{4,f},{3,d}], + true = lists:keysort(1, L) == + qlc:e(qlc:q([X || X <- qlc:keysort(1,L)])), + true = lists:ukeysort(1, L) == + qlc:e(qlc:q([X || X <- qlc:keysort(1, L, {unique,true})])), + true = lists:reverse(lists:keysort(1, L)) == + qlc:e(qlc:q([X || X <- qlc:keysort(1,L, + {order, descending})])), + true = lists:reverse(lists:ukeysort(1, L)) == + qlc:e(qlc:q([X || X <- qlc:keysort(1, L, [{unique,true}, + {order, descending}])]))">>, + + <<"L = [{X} || X <- lists:seq(1,100000)], + H1 = qlc:append([L,[{1,2},{2,3},{3,4}]]), + H = qlc:keysort([1], qlc:keysort([1], H1, [{compressed,true}])), + R = qlc:e(H), + 100003 = length(R)">> + + ], + ?line run(Config, Ts), + + ok. + +filesort(doc) -> + "keysort/1,2, using a file."; +filesort(suite) -> []; +filesort(Config) when is_list(Config) -> + Ts = [ + <<"Q = qlc:q([X || X <- [{3},{1},{2}]]), + Opts = [{size,10},{no_files,3}], + Q2 = qlc:q([{X,Y} || Y <- [1,2], X <- qlc:keysort([1],Q,Opts)]), + [{{1},1},{{2},1},{{3},1},{{1},2},{{2},2},{{3},2}] = qlc:e(Q2)">> + ], + ?line run(Config, Ts), + ok. + + +cache(doc) -> + "The cache option."; +cache(suite) -> []; +cache(Config) when is_list(Config) -> + Ts = [ + <<"{'EXIT', {badarg, _}} = (catch qlc:q([X || X <- [1,2]], badarg))">>, + + <<"Q1 = qlc:q([X || X <- [1,2,1,2,1]], {unique,true}), + [1,2] = qlc:e(Q1), + [1,2] = qlc:e(Q1, {unique_all,true}), + Q2 = qlc:q([X || X <- qlc:q([X || X <- [1,2,1,2,1]], + {unique,true})]), + [1,2] = qlc:e(Q2), + [1,2] = qlc:e(Q2, {unique_all,true}), + Q3 = qlc:q([X || X <- qlc:append([[1,2,3], [4,5,6]])]), + [1,2,3,4,5,6] = qlc:e(Q3)">>, + + <<"Q1 = qlc:q([X || {X,_} <- [{1,a},{2,a},{1,b},{2,b}]]), + Q2 = qlc:q([{X,make_ref()} || X <- Q1]), + [{1,_},{2,_},{1,_},{2,_}] = qlc:e(Q2, {unique_all,false}), + [{1,_},{2,_}] = qlc:e(Q2, {unique_all,true})">>, + + <<"E = ets:new(test, [duplicate_bag]), + true = ets:insert(E, [{1,a},{2,a},{1,b},{2,b}]), + Q1 = qlc:q([X || {X,_} <- ets:table(E)]), + Q2 = qlc:q([{X,make_ref()} || X <- Q1]), + [{1,_},{1,_},{2,_},{2,_}] = lists:sort(qlc:e(Q2, {unique_all,false})), + [{1,_},{2,_}] = lists:sort(qlc:e(Q2, {unique_all,true})), + ets:delete(E)">>, + + <<"Q1 = qlc:q([X || {X,_} <- [{1,a},{2,a},{1,b},{2,b}]]), + Q2 = qlc:q([{X,make_ref()} || X <- qlc:append([Q1, Q1])]), + [{1,_},{2,_},{1,_},{2,_},{1,_},{2,_},{1,_},{2,_}] = + qlc:e(Q2, {unique_all,false}), + [{1,_},{2,_}] = qlc:e(Q2, {unique_all,true})">>, + + <<"[] = qlc:e(qlc:q([X || X <- []], {unique, true})), + [] = qlc:e(qlc:q([X || X <- qlc:q([X || X <- qlc:append([])], + {unique,true})]))">>, + + <<"Q1 = qlc:q([{X,make_ref()} || {X,_} <- [{1,a},{1,b}]]), + [{1,_},{1,_}] = qlc:e(Q1, {unique_all, true}), + Q2 = qlc:q([Y || {X,_} <- [{1,a},{1,b}], + begin Y = {X,make_ref()}, true end]), + [{1,_},{1,_}] = qlc:e(Q2, {unique_all,true}), + Q3 = qlc:q([Y || X <- [{1,a},{2,a}], + begin {_,Z} = X, Y = {Z,make_ref()}, true end]), + [{a,_},{a,_}] = qlc:e(Q3, {unique_all, true})">>, + + <<"E = ets:new(apa, [duplicate_bag]), + ets:insert(E, [{1,a},{2,a},{1,a}]), + H1 = qlc:q([X || X <- qlc:append(ets:table(E),[7,3,5])], + {cache, true}), + [{_,a},{_,a},{_,a},7,3,5] = qlc:e(H1), + ets:delete(E)">>, + + <<"F = fun(Obj, A) -> A++[Obj] end, + H = qlc:q([X || X <- [1,3,2,4]], cache), + Q = qlc:q([X || X <- H]), + [1,3,2,4] = qlc:fold(F, [], Q, [])">>, + + <<"F = fun(Obj, A) -> A++[Obj] end, + E = ets:new(apa, [duplicate_bag]), + true = ets:insert(E, [{1,a},{2,b},{1,a}]), + Q1 = qlc:q([X || X <- ets:table(E)], [cache, unique]), + Q = qlc:q([X || X <- Q1], [cache, unique]), + {qlc, _, [{generate, _,{table,_}}], [{unique,true}]} = i(Q), + R = qlc:fold(F, [], Q, []), + ets:delete(E), + true = [{1,a},{2,b}] == lists:sort(R)">>, + + <<"E = ets:new(apa, [duplicate_bag]), + ets:insert(E, [{1,a},{2,b},{1,a}]), + H1 = qlc:q([X || X <- qlc:append(ets:table(E),[7,3])], cache), + H2 = qlc:q([{Y,X} || Y <- [2,1,3], X <- H1]), + [{2,_},{2,_},{2,_},{2,7},{2,3}, + {1,_},{1,_},{1,_},{1,7},{1,3}, + {3,_},{3,_},{3,_},{3,7},{3,3}] = qlc:e(H2), + ets:delete(E)">>, + + %% This case is not 100 percent determined. An Ets table + %% is updated in a filter and later used in a generator. + <<"E = ets:new(apa, [bag]), + true = ets:insert(E, [{1,a},{2,b}]), + H1 = qlc:q([Y || Y <- ets:table(E)], + [{cache, no}, {unique, true}]), + H = qlc:q([{X,Y} || X <- [{1,a},{2,d},{3,e}], + ets:insert(E, X), + Y <- H1]), + [{{1,a},_}, {{1,a},_}, {{2,d},_}, {{2,d},_}, {{2,d},_}, + {{3,e},_}, {{3,e},_}, {{3,e},_}, {{3,e},_}] = qlc:e(H), + ets:delete(E)">>, + + %% This case is not 100 percent determined. An Ets table + %% is updated in a filter and later used in a generator. + <<"E = ets:new(apa, [bag]), + true = ets:insert(E, [{1,a},{2,b}]), + H1 = qlc:q([Y || Y <- ets:table(E)], + [{cache, true}, {unique, true}]), + H = qlc:q([{X,Y} || X <- [{1,a},{2,d},{3,e}], + ets:insert(E, X), + Y <- H1]), + [{{1,a},_}, {{1,a},_}, {{2,d},_}, {{2,d},_}, {{3,e},_}, {{3,e},_}] = + qlc:e(H), + ets:delete(E)">>, + + <<"%% {5979} and {5549} are both hashed to 28244 by phash2/1 + E = ets:new(apa, [duplicate_bag]), + true = ets:insert(E, [{5979},{5549},{5979},{5549},{0}]), + H1 = qlc:q([X || X <- ets:table(E)], + [{cache, true}, {unique, true}]), + H = qlc:q([Y || _ <- [1,2], Y <- H1]), + {qlc, _, [{generate, _, {list, [1,2]}}, + {generate, _, {qlc, _, [{generate, _, {table,_}}], + [{cache,ets},{unique,true}]}}], + []} = i(H), + [{0},{0},{5549},{5549},{5979},{5979}] = lists:sort(qlc:e(H)), + ets:delete(E)">>, + + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H1 = qlc:q([X || X <- ets:table(E)], [cache, unique]), + H2 = qlc:q([X || Y <- [3,4], ets:insert(E, {Y}), X <- H1]), + {qlc, _, [{generate, _, {list, [3,4]}}, _, + {generate, _, {qlc, _, [{generate, _, + {table, _}}], + [{cache, ets}]}}], + []} = i(H2), + [{1},{2},{3},{1},{2},{3}] = qlc:e(H2), + ets:delete(E)">>, + + <<"E = ets:new(apa, [ordered_set]), + ets:insert(E, [{1},{2}]), + H1 = qlc:q([X || X <- ets:table(E)], [unique]), + H2 = qlc:q([X || Y <- [3,4], ets:insert(E, {Y}), X <- H1]), + [{1},{2},{3},{1},{2},{3},{4}] = qlc:e(H2), + ets:delete(E)">>, + + <<"H0 = qlc:append([a,b], [c,d]), + H = qlc:q([{X,Y} || + X <- H0, + Y <- qlc:q([{X1,Y} || + X1 <- H0, + Y <- qlc:q([{X2,Y} || + X2 <- H0, + Y <- H0])])]), + {qlc, _, + [{generate, _,{append, [{list, [a,b]}, {list, [c,d]}]}}, + {generate, _, + {qlc, _, + [{generate, _, {append,[{list, [a,b]},{list, [c,d]}]}}, + {generate, _, + {qlc, _, + [{generate, _,{append,[{list, [a,b]}, {list, [c,d]}]}}, + {generate, _,{append,[{list, [a,b]}, {list, [c,d]}]}}], + [{cache,ets}]}}], + [{cache,ets}]}}], + []} = i(H, cache_all)">> + + ], + ?line run(Config, Ts), + ok. + +cache_list(doc) -> + "OTP-6038. The {cache,list} option."; +cache_list(suite) -> []; +cache_list(Config) when is_list(Config) -> + Ts = [ + begin + PrivDir = ?privdir, + [<<"%% unique, cache list. A simple qlc. + Options = [{cache,list}, unique], + L0 = [1,2,3,4,1,2,3,4], + L = qlc_SUITE:table(L0, []), + Q1 = qlc:q([X || X <- L], Options), + Q = qlc:q([{X,Y} || X <- [a,b], Y <- Q1]), + GOptions = [{tmpdir,\"">>, PrivDir, <<"\"}], + {qlc,_,[{generate,_,{list,[a,b]}}, + {generate,_,{qlc,_, + [{generate,_,{table,_}}], + [{cache,list},{unique,true}]}}], + []} = i(Q, GOptions), + true = [{X,Y} || X <- [a,b], Y <- [1,2,3,4]] =:= + qlc:e(Q, GOptions)">>] + end, + + begin + MS = ets:fun2ms(fun({X,_}) when X > 1 -> X end), + [<<"%% No cache, even if explicit match specification. + etsc(fun(E) -> + MS = ">>, io_lib:format("~w", [MS]), <<", + Options = [{cache,list}, unique], + Q = qlc:q([{X,Y} || + X <- ets:table(E, {traverse, {select, MS}}), + Y <- [1,2,3]], + Options), + {qlc,_,[{generate,_,{table,{ets,table,_}}}, + {generate,_,{list,[1,2,3]}}], + [{unique,true}]} = i(Q), + true = [{X,Y} || X <- lists:seq(2,10), Y <- [1,2,3]] =:= + lists:sort(qlc:e(Q)) + end, [{keypos,1}], [{I,a} || I <- lists:seq(1, 10)])">>] + end, + + <<"%% Temporary files. + %% Remove list expression caches when possible. (no visible effect) + T = lists:seq(1, 100000), % Huge terms on file + F = fun(C) -> + Q0 = qlc:q([{X} || X <- [T,T,T], begin X > 0 end], + {cache,C}), + Q1 = qlc:q([{X,Y,Z} || + X <- Q0, + Y <- Q0, + Z <- Q0], + {cache,C}), + qlc:q([{X, Y} || Y <- [1], X <- Q1]) + end, + Ql = F(list), + Rl = qlc:e(Ql, {max_list_size, 64*1024}), + Qe = F(ets), + Re = qlc:e(Qe), + Qf = F(no), + Rf = qlc:e(Qf), + Ri = qlc:e(Ql, {max_list_size, 1 bsl 35}), % heavy + {27,27,27,27,true,true,true} = + {length(Rl), length(Re), length(Rf), length(Ri), + Rl =:= Re, Re =:= Rf, Rf =:= Ri}">>, + + <<"%% File sorter. + T = lists:seq(1, 10000), + F = fun(C) -> + Q0 = qlc:q([{X} || X <- [T,T,T], begin X > 0 end], + [{cache,C},unique]), + Q1 = qlc:q([{X,Y,Z} || + X <- Q0, + Y <- Q0, + Z <- Q0], + [{cache,C},unique]), + qlc:q([{X, Y} || Y <- [1], X <- Q1]) + end, + GOpt = [{max_list_size, 10000}], + Ql = F(list), + Rl = qlc:e(Ql, GOpt), + Qe = F(ets), + Re = qlc:e(Qe, GOpt), + Qf = F(no), + Rf = qlc:e(Qf, GOpt), + {1,1,1,true,true} = + {length(Rl), length(Re), length(Rf), Rl =:= Re, Re =:= Rf}">>, + + <<"%% Remove list expression caches when possible. (no visible effect) + Q0 = qlc:q([{X} || X <- [1,2,3], begin X > 0 end], {cache,list}), + Q1 = qlc:q([{X,Y,Z} || + X <- Q0, + Y <- Q0, + Z <- Q0], + {cache,list}), + Q = qlc:q([{X, Y} || Y <- [1], X <- Q1]), + R = qlc:e(Q), + L0 = [{X} || X <- [1,2,3], begin X > 0 end], + L1 = [{X,Y,Z} || + X <- L0, + Y <- L0, + Z <- L0], + L = [{X, Y} || Y <- [1], X <- L1], + true = R =:= L">>, + + <<"%% No temporary file. + L = [{I,a} || I <- lists:seq(1, 10)], + Q0 = qlc:q([X || X <- qlc_SUITE:table_error(L, 1, err), + begin element(1, X) > 5 end], + {cache,list}), + Q = qlc:q([{X, element(1,Y)} || + X <- lists:seq(1, 5), + Y <- Q0]), + err = qlc:e(Q)">>, + + <<"%% Sort internally. + L = [{I,a} || I <- lists:seq(1, 10)], + Q0 = qlc:q([X || X <- qlc_SUITE:table_error(L, 1, err), + begin element(1, X) > 5 end], + [unique,{cache,list}]), + Q = qlc:q([{X, element(1,Y)} || + X <- lists:seq(1, 5), + Y <- Q0]), + err = qlc:e(Q, {max_list_size,0})">>, + + <<"%% No temporary file. + etsc(fun(E) -> + Q0 = qlc:q([X || X <- ets:table(E), + begin element(1, X) > 5 end], + {cache,list}), + Q = qlc:q([{X, element(1,Y)} || X <- lists:seq(1, 5), + Y <- Q0]), + R = [{X,Y} || X <- lists:seq(1, 5), + Y <- lists:seq(6, 10)], + R = lists:sort(qlc:e(Q)) + end, [{keypos,1}], [{I,a} || I <- lists:seq(1, 10)])">>, + + <<"%% Sort internally + etsc(fun(E) -> + Q0 = qlc:q([X || X <- ets:table(E), + begin element(1, X) > 5 end], + [{cache,list},unique]), + Q = qlc:q([{X, element(1,Y)} || X <- lists:seq(1, 5), + Y <- Q0]), + R = [{X,Y} || X <- lists:seq(1, 5), + Y <- lists:seq(6, 10)], + R = lists:sort(qlc:e(Q)) + end, [{keypos,1}], [{I,a} || I <- lists:seq(1, 10)])">>, + + <<"%% A few more tests of unique and {cache,list}. + F = fun(CU) -> + H1 = qlc:q([{X,Y} || + Y <- [a,b], + X <- [1,2]], + CU), + qlc:q([{X,Y,Z} || X <- [3,4], {Y,Z} <- H1]) + end, + Q1 = F([]), + Q2 = F([{cache,list}, unique]), + R1 = qlc:e(Q1), + R2 = qlc:e(Q2), + R3 = qlc:e(Q2, {max_list_size, 0}), % still in RAM + true = R1 =:= R2, + true = R2 =:= R3">>, + + <<"E = ets:new(t, [duplicate_bag]), + true = ets:insert(E, [{2},{1},{2}]), + H1 = qlc:q([{X,Y} || + Y <- [a,b], + {X} <- ets:table(E)], + [{cache,list}, unique]), + H2 = qlc:q([{X,Y,Z} || X <- [3,4], {Y,Z} <- H1]), + {qlc,_,[{generate,_,{list,[3,4]}}, + {generate,_,{qlc,_, + [{generate,_,{list,[a,b]}}, + {generate,_, + {qlc,_,[{generate,_,{table,{ets,table,_}}}], + [{cache,list},{unique,true}]}}], + [{cache,list},{unique,true}]}}], []} = i(H2), + L1s = [[{X,Y} || Y <- [a,b], X <- Xs] || Xs <- [[1,2], [2,1]]], + L2s = [[{X,Y,Z} || X <- [3,4], {Y,Z} <- L1] || L1 <- L1s], + R1 = qlc:e(H2), + R2 = qlc:e(H2, {max_list_size, 0}), % on temporary file + ets:delete(E), + true = lists:member(R1, L2s), + true = R1 =:= R2">>, + + <<"E = ets:new(t, [duplicate_bag]), + true = ets:insert(E, [{2},{1},{2}]), + H1 = qlc:q([{X,Y} || + Y <- [a,b], + {X} <- ets:table(E)], + [{cache,list}]), + H2 = qlc:q([{X,Y,Z} || X <- [3,4], {Y,Z} <- H1]), + L1s = [[{X,Y} || Y <- [a,b], X <- Xs] || Xs <- [[1,2,2], [2,2,1]]], + L2s = [[{X,Y,Z} || X <- [3,4], {Y,Z} <- L1] || L1 <- L1s], + R1 = qlc:e(H2), + R2 = qlc:e(H2, {max_list_size, 0}), % on temporary file + ets:delete(E), + true = lists:member(R1, L2s), + true = R1 =:= R2">>, + + <<"Q1 = qlc:q([{X,Y} || + Y <- [a,b], + {X,_} <- qlc_SUITE:table_error([{a,1}], 2, err)], + [{cache,list}, unique]), + Q = qlc:q([{X,Y,Z} || X <- [3,4], {Y,Z} <- Q1]), + {qlc,_,[{generate,_,{list,[3,4]}}, + {generate,_,{qlc,_, + [{generate,_,{list,[a,b]}}, + {generate,_,{table,_}}], + [{cache,list},{unique,true}]}}], + []} = i(Q), + err = qlc:e(Q,{max_list_size,0})">>, + + begin + Privdir = ?privdir, + [<<" + E = ets:new(t, [duplicate_bag]), + N = 17000, + true = ets:insert(E, [{X,X} || X <- lists:seq(1, N)]), + N = ets:info(E, size), + RF = fun(GOpts) -> + F = fun(CU) -> + H1 = qlc:q([{X,Y} || + Y <- [a,b], + {X,_} <- ets:table(E)], + CU), + qlc:q([{X,Y,Z} || X <- [3,4], {Y,Z} <- H1]) + end, + Q1 = F([{cache,list}, unique]), + _ = qlc:info(Q1, GOpts), + R1 = qlc:e(Q1, GOpts), + Q2 = F([unique]), + R2 = qlc:e(Q2, GOpts), + true = lists:sort(R1) =:= lists:sort(R2) + end, + GOpts = [{tmpdir,\"">>,Privdir,<<"\"}], + RF([{max_list_size, 1 bsl 35} | GOpts]), + RF(GOpts), + RF([{max_list_size, 40000} | GOpts]), + true = ets:insert(E, [{X,X} || X <- lists:seq(1, N)]), + true = N+N =:= ets:info(E, size), + RF([{max_list_size, 1 bsl 30} | GOpts]), + RF(GOpts), + RF([{max_list_size, 40000} | GOpts]), + ets:delete(E)">>] + end, + + <<"%% Temporary file employed. + etsc(fun(E) -> + Q0 = qlc:q([X || X <- ets:table(E), + begin element(1, X) > 5 end], + {cache,list}), + Q = qlc:q([{X, element(1,Y)} || X <- lists:seq(1, 5), + Y <- Q0]), + R = [{X,Y} || X <- lists:seq(1, 5), + Y <- lists:seq(6, 10)], + R = lists:sort(qlc:e(Q, {max_list_size, 100*1024})) + end, [{keypos,1}], [{I,a,lists:duplicate(100000,1)} || + I <- lists:seq(1, 10)])">>, + + <<"%% Temporary file employed. The file is removed after error. + L = [{I,a,lists:duplicate(100000,1)} || I <- lists:seq(1, 10)], + Q0 = qlc:q([X || X <- qlc_SUITE:table_error(L, 1, err), + begin element(1, X) > 5 end], + {cache,list}), + Q = qlc:q([{X, element(1,Y)} || + X <- lists:seq(1, 5), + Y <- Q0]), + err = qlc:e(Q)">>, + + <<"%% Temporary file employed. The file is removed after error. + L = [{I,a,lists:duplicate(100000,1)} || I <- lists:seq(1, 10)], + Q0 = qlc:q([X || X <- qlc_SUITE:table(L, 1, []), + begin element(1, X) > 5 end], + {cache,list}), + Q = qlc:q([{X, element(1,Y)} || + X <- lists:seq(1, 5), + Y <- Q0]), + {error, _, {file_error,_,_}} = qlc:e(Q, {tmpdir, \"/a/b/c\"})">>, + + <<"Q = qlc:q([X || X <- [1,2]]), + {'EXIT', {badarg, _}} = (catch qlc:e(Q, {max_list_size, -1}))">>, + + <<"Q = qlc:q([X || X <- [1,2]]), + {'EXIT', {badarg, _}} = (catch qlc:e(Q, {max_list_size, foo}))">> + + ], + ?line run(Config, Ts), + ok. + +filter(doc) -> + "Filters and match specs."; +filter(suite) -> []; +filter(Config) when is_list(Config) -> + Ts = [ + <<"L = [1,2,3,4,5], + QH1 = qlc:q([X || X <- L, X > 1, X < 4]), + [2,3] = qlc:e(QH1), + {list,{list,L},_MS} = i(QH1) + ">>, + + <<"L = [1,2,3,4,5], + QH2 = qlc:q([X || X <- L, X > 1, X < 4, X > 2]), + [3] = qlc:e(QH2), + {list,{list,L},_MS} = i(QH2) + ">>, + + %% "X > 1" is skipped since the matchspec does the job + <<"QH3 = qlc:q([X || X <- [1,2,3,4,5], X > 1, begin X < 4 end]), + [2,3] = qlc:e(QH3), + {qlc,_,[{generate,_,{list,{list,[1,2,3,4,5]},_MS}},_],[]} = i(QH3) + ">>, + + <<"QH4 = qlc:q([{X,Y} || X <- [1,2], Y <- [1,2]]), + [{1,1},{1,2},{2,1},{2,2}] = qlc:e(QH4), + {qlc,_,[{generate,_,{list,[1,2]}},{generate,_,{list,[1,2]}}],[]} = + i(QH4)">>, + + %% "X > 1" is skipped since the matchspec does the job + <<"QH5 = qlc:q([{X,Y} || X <- [1,2], X > 1, Y <- [1,2]]), + [{2,1},{2,2}] = qlc:e(QH5), + {qlc,_,[{generate,_,{list,{list,[1,2]},_MS}}, + {generate,_,{list,[1,2]}}],[]} = + i(QH5)">>, + + <<"%% Binaries are not handled at all when trying to find lookup values + etsc(fun(E) -> + A = 2, + Q = qlc:q([X || {X} <- ets:table(E), <<A>> =:= <<X>>]), + [2] = lists:sort(qlc:e(Q)), + false = lookup_keys(Q) + end, [{1},{2},{3}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,_} <- ets:table(E), + qlc:e(qlc:q([Y || {Y,_} <- ets:table(E), + Y > X])) == []]), + [3] = qlc:e(Q) + end, [{1,a},{2,b},{3,c}])">>, + + <<"Q = qlc:q([X || {X} <- [], (false or (X/0 > 3))]), + \"[]\" = qlc:info(Q), + [] = qlc:e(Q)">>, + + <<"%% match spec + [] = qlc:e(qlc:q([X || {X} <- [{1},{2}], + (false orelse (X/0 > 3))])), + %% generated code + {'EXIT', {badarith, _}} = + (catch qlc:e(qlc:q([X || {X} <- [{1}], + begin (false orelse (X/0 > 3)) end])))">>, + + <<"%% Partial evaluation in filter. + etsc(fun(E) -> + QH = qlc:q([{X+1,Y} || {X,Y} <- ets:table(E), + X =:= 1-1+1+(+1)]), + [{3,2}] = qlc:e(QH), + [2] = lookup_keys(QH) + end, [{1,1},{2,2},{3,3}])">>, + + <<"%% =/2 in filters must not be recognized when 'badmatch' is + %% possible. + etsc(fun(E) -> + QH = qlc:q([{X,Y} || {X,Y} <- ets:table(E), + ((Y = X) =:= 3)]), + {'EXIT', {{badmatch,4},_}} = (catch qlc:e(QH)), + false = lookup_keys(QH) + end, [{3,3},{4,true}])">>, + + <<"%% One more of the same kind. + etsc(fun(E) -> + QH = qlc:q([{X,Y} || {X,_} <- ets:table(E), + (Y=X) =:= (Y=1+1)]), + {'EXIT', {{badmatch,2},_}} = (catch qlc:e(QH)), + false = lookup_keys(QH) + end, [{1,1},{2,2},{3,3}])">>, + + <<"%% OTP-5195. Used to return a value, but badarith is correct. + etsc(fun(E) -> + QH = qlc:q([X || {X,_} <- ets:table(E), + (X =:= 1) and + if X =:= 1 -> true; + true -> X/0 + end]), + {'EXIT',{badarith,_}} = (catch qlc:e(QH)), + false = lookup_keys(QH) + end, [{1,1},{2,2},{3,3}])">>, + + <<"fun(Z) -> + Q = qlc:q([X || Z < 2, X <- [1,2,3]]), + [] = qlc:e(Q) + end(3)">>, + + <<"H = qlc:q([{P1,A,P2,B,P3,C} || + P1={A,_} <- [{1,a},{2,b}], + {_,B}=P2 <- [{1,a},{2,b}], + C=P3 <- [1], + {[X,_],{_,X}} <- [{[1,2],{3,1}}, {[a,b],{3,4}}], + A > 0, + B =/= c, + C > 0]), + L = [{{1,a},1,{1,a},a,1,1}, {{1,a},1,{2,b},b,1,1}, + {{2,b},2,{1,a},a,1,1}, {{2,b},2,{2,b},b,1,1}], + L = qlc:e(H)">>, + + <<"H = qlc:q([{X,Y} || + X = _ <- [1,2,3], + _ = Y <- [a,b,c], + _ = _ <- [foo], + X > 1, + Y =/= a]), + [{2,b},{2,c},{3,b},{3,c}] = qlc:e(H)">> + + ], + ?line run(Config, Ts), + ok. + +info(doc) -> + "info/2."; +info(suite) -> []; +info(Config) when is_list(Config) -> + Ts = [ + <<"{list, [1,2]} = i(qlc:q([X || X <- [1,2]])), + {append,[{list, [1,2]}, {list, [3,4]}]} = + i(qlc:append([1,2],[3,4])), + {sort,{list, [1,2]},[]} = i(qlc:sort([1,2])), + E = ets:new(foo, []), + ets:insert(E, [{1},{2}]), + {table, _} = i(ets:table(E)), + true = ets:delete(E), + {list, [1,2]} = i([1,2]), + {append, [{list, [1,2]}, {list, [3,4]}]} = + i(qlc:q([X || X <- qlc:append([1,2],[3,4])])), + + H0 = qlc:q([X || X <- throw({throw,t})]), + {throw,t} = (catch {any_term,qlc:info(H0)}), + {'EXIT', {badarg, _}} = + (catch qlc:info(foobar)), + {'EXIT', {badarg, _}} = + (catch qlc:info(qlc:q([X || X <- [1,2]]), badarg))">>, + + <<"{'EXIT', {badarg, _}} = + (catch qlc:info([X || {X} <- []], {n_elements, 0})), + L = lists:seq(1, 1000), + \"[1,2,3,4,5,6,7,8,9,10|'...']\" = qlc:info(L, {n_elements, 10}), + {cons,1,{integer,1,1},{atom,1,'...'}} = + qlc:info(L, [{n_elements, 1},{format,abstract_code}]), + Q = qlc:q([{X} || X <- [a,b,c,d,e,f]]), + {call,_,_,[{cons,_,{atom,_,a},{cons,_,{atom,_,b},{cons,_,{atom,_,c}, + {atom,_,'...'}}}}, + {call,_,_,_}]} = + qlc:info(Q, [{n_elements, 3},{format,abstract_code}]), + \"ets:match_spec_run([a,b,c,d,e,f],\n\" + \" ets:match_spec_compile([{'$1',[true],\" + \"[{{'$1'}}]}]))\" = + qlc:info(Q, [{n_elements, infinity}])">>, + + <<"Q1 = qlc:q([{X} || X <- qlc:q([X || X <- [1,2]])]), + {qlc, _, [{generate, _, {list, [1,2]}}],[]} = i(Q1), + Q2 = qlc:q([X || X <- qlc:q([{X} || X <- [1,2]])]), + {list,{list,[1,2]},_} = i(Q2), + [{1},{2}] = qlc:eval(Q2), + Q3 = qlc:q([{X,Y} || X <- qlc:q([X || X <- [a,b]]), + Y <- qlc:q([Z || Z <- [a,b]])]), + {qlc, _, [{generate, _, {list, [a,b]}}, + {generate, _, {list, [a,b]}}], []} = i(Q3), + Q4 = qlc:q([X || X <- [a]]), + {list, [a]} = i(Q4), + Q5 = qlc:q([X || X <- qlc:q([Y || Y <- [a,b]], unique)]), + {qlc, _, [{generate, _, {list, [a,b]}}], [{unique,true}]} = + i(Q5)">>, + + <<"H = qlc:q([X || X <- qlc:append([qlc:q([X || X <- [1,2]]),[1,2]])]), + {append, [{list, [1,2]},{list, [1,2]}]} = i(H), + [1,2,1,2] = qlc:e(H)">>, + + <<"H = qlc:q([{X} || X <- [], X > 1]), + {list, []} = i(H), + [] = qlc:e(H)">>, + + <<"H1 = qlc:q([{X} || X <- [], X > 1]), + H = qlc:q([{X} || X <- H1, X < 10]), + {list, []} = i(H), + [] = qlc:e(H)">>, + + <<"L = [1,2,3], + QH1 = qlc:q([{X} || X <- L, X > 1]), + QH2 = qlc:q([{X} || X <- QH1]), + [{{2}},{{3}}] = qlc:e(QH2), + {list,{list,{list,L},_},_} = i(QH2)">>, + + <<"H = qlc:q([X || X <- qlc:q([Y || Y <- qlc:q([Z || Z <-[1,2,1]])])]), + {list, [1,2,1]} = i(H), + [1,2,1] = qlc:eval(H)">>, + + <<"%% Used to replace empty ETS tables with [], but that won't work. + E = ets:new(apa,[]), + QH1 = qlc:q([{X} || X <- ets:table(E), X > 1]), + QH2 = qlc:q([{X} || X <- QH1], cache), + [] = qlc:e(QH2), + {qlc,_,[{generate,_,{table,{ets,table,_}}}],[]} = i(QH2), + ets:delete(E)">>, + + <<"Q1 = qlc:q([W || W <- [a,b]]), + Q2 = qlc:q([Z || Z <- qlc:sort([1,2,300])], unique), + Q3 = qlc:q([{X,Y} || X <- qlc:keysort([2], [{1,a}]), + Y <- qlc:append([Q1, Q2]), + X > Y]), + {qlc, T1, + [{generate, P1, {list, [{1,a}]}}, + {generate, P2, {append, [{list, [a,b]}, + {qlc, T2, [{generate, P3, + {sort, {list,[1,2,300]},[]}}], + [{cache,ets},{unique,true}]}]}},F], + []} = i(Q3, cache_all), + {tuple, _, [{var,_,'X'}, {var,_,'Y'}]} = binary_to_term(T1), + {var, _, 'X'} = binary_to_term(P1), + {var, _, 'Y'} = binary_to_term(P2), + {var, _, 'Z'} = binary_to_term(P3), + {var, _, 'Z'} = binary_to_term(T2), + {op, _, '>', {var, _, 'X'}, {var, _, 'Y'}} = binary_to_term(F), + true = binary_to_list(<< + \"beginV1=qlc:q([Z||Z<-qlc:sort([1,2,300],[])],[{unique,true}]),\" + \"qlc:q([{X,Y}||X<-[{1,a}],Y<-qlc:append([[a,b],V1]),X>Y])end\" + >>) == format_info(Q3, true)">>, + + <<"Q1 = qlc:q([{X} || X <- qlc:q([X || X <- [a,b]])]), + {qlc, _, [{generate, _, {list, [a,b]}}], []} = i(Q1), + Q2 = qlc:q([X || X <- qlc:q([{X} || X <- [a,b]])]), + {list,{list,[a,b]},_} = i(Q2), + [{a},{b}] = qlc:eval(Q2)">>, + + <<"Q = qlc:keysort(2, [{1,a,b},{2,b,c},{3,4,c}]), + {keysort,{list,[{1,a,b},{2,b,c},{3,4,c}]},2,[]} = i(Q), + true = binary_to_list(<< + \"qlc:keysort(2,[{1,a,b},{2,b,c},{3,4,c}],[])\">>) + == format_info(Q, true), + [{3,4,c},{1,a,b},{2,b,c}] = qlc:e(Q)">>, + + <<"E = ets:new(foo, []), + ets:insert(E, [{1},{2}]), + Q = qlc_SUITE:default_table(E), + {table,{'$MOD','$FUN',[]}} = i(Q), + true = binary_to_list(<<\"'$MOD':'$FUN'()\">>) + == format_info(Q, true), + true = ets:delete(E)">>, + + <<"\"[]\" = qlc:info([], flat), + \"[]\" = qlc:info([]), + \"[]\" = qlc:info([], {flat, true})">>, + + <<"H = qlc:q([{X} || X <- [a,b]]), + \"ets:match_spec_run([a,b],ets:match_spec_compile(\" ++ _ = + format_info(H, true), + \"ets:match_spec_run([a,b],ets:match_spec_compile(\" ++ _ = + format_info(H, false)">>, + + <<"H = qlc:q([{X} || X <- [a,b], begin true end]), + true = binary_to_list(<<\"qlc:q([{X}||X<-[a,b],begintrueend])\">>) + == format_info(H, true), + true = binary_to_list(<<\"qlc:q([{X}||X<-[a,b],begintrueend])\">>) + == format_info(H, false)">>, + + <<"H = qlc:q([A || {A} <- [{1},{2}], (A =:= 2) andalso true]), + {call,_,{remote,_,{atom,_,ets},{atom,_,match_spec_run}},_} = + qlc:info(H, {format,abstract_code})">>, + + <<"H = qlc:q([{X} || X <- qlc:q([{X} || X <- [a,b], begin true end], + unique), + begin true end]), + true = binary_to_list(<< + \"beginV1=qlc:q([{X}||X<-[a,b],begintrueend],[{unique,true}]),\" + \"qlc:q([{X}||X<-V1,begintrueend])end\">>) == + format_info(H, true), + true = binary_to_list(<< + \"qlc:q([{X}||X<-qlc:q([{X}||X<-[a,b],begintrueend],\" + \"[{unique,true}]),begintrueend])\">>) == format_info(H, false)">>, + + <<"H0 = qlc:q([{V3} || V3 <- qlc:q([{V1} || V1 <- [a,b], + begin true end], unique), + begin true end]), + H = qlc:sort(H0), + true = binary_to_list(<< + \"qlc:sort(qlc:q([{V3}||V3<-qlc:q([{V1}||\" + \"V1<-[a,b],begintrueend],[{unique,true}]),begintrueend]),[])\">>) + == format_info(H, false), + true = binary_to_list(<< + \"beginV2=qlc:q([{V1}||V1<-[a,b],begintrueend],[{unique,true}]),\" + \"V4=qlc:q([{V3}||V3<-V2,begintrueend]),qlc:sort(V4,[])end\">>) + == format_info(H, true)">>, + + <<"H0 = qlc:q([X || X <- [true], begin true end]), + H1 = qlc:q([{X} || X <- [a,b], begin true end], + [{unique,begin [T] = qlc:e(H0), T end}]), + {call,_,{remote,_,{atom,_,qlc},{atom,_,q}}, + [{lc,_,{tuple,_,[{var,_,'X'}]}, + [{generate,_,{var,_,'X'}, + {cons,_,{atom,_,a},_}}, + {block, _, [{atom, _, true}]}]}, + {cons,_,_,_}]} = i(H1, {format, abstract_code})">>, + + <<"E = ets:new(apa, [duplicate_bag]), + true = ets:insert(E, [{1,a},{2,b},{3,c},{4,d}]), + QH = qlc:q([X || {X,_} <- ets:tab2list(E), X > 2], unique), + {qlc, _, [{generate, _, {list, _, _MS}}], [{unique, true}]} = + i(QH), + [3,4] = lists:sort(qlc:e(QH)), + ets:delete(E)">>, + + %% "Imported" variable. + <<"F = fun(U) -> qlc:q([{X} || X <- [1,2,3,4,5,6], X > U]) end, + QH = F(4), + {call, _ , + {remote, _, {atom, _, ets},{atom, _, match_spec_run}}, + [{string, _, [1,2,3,4,5,6]}, + {call, _, + _compile, + [{cons, _, + {tuple, _, + [{atom, _,'$1'}, + {cons, _, + {tuple, + _, + [{atom, _,'>'}, + {atom, _,'$1'}, + {tuple, + _, + [{atom, _,const}, + {integer, _,4}]}]}, + _}, + {cons, _, _, _}]}, + {nil,_}}]}]} = i(QH, {format, abstract_code}), + [{5},{6}] = qlc:e(QH), + [{4},{5},{6}] = qlc:e(F(3))">> + + ], + ?line run(Config, Ts), + ok. + +nested_info(doc) -> + "Nested QLC expressions. QLC expressions in filter and template."; +nested_info(suite) -> []; +nested_info(Config) when is_list(Config) -> + Ts = [ + <<"L = [{1,a},{2,b},{3,c}], + Q = qlc:q( + [{X,R} || + {X,_} <- qlc_SUITE:table(L, []), + begin % X imported + R = qlc:e(qlc:q([{X,Y} || {Y,_} + <- qlc_SUITE:table(L, []), + Y > X])), + true + end]), + true = binary_to_list(<< + \"qlc:q([{X,R}||{X,_}<-qlc_SUITE:the_list([{1,a},{2,b},{3,c}]),\" + \"beginR=qlc:e(qlc:q([{X,Y}||{Y,_}<-qlc_SUITE:table(L,[]),Y>X]))\" + \",trueend])\">>) == format_info(Q, true), + [{1,[{1,2},{1,3}]},{2,[{2,3}]},{3,[]}] = qlc:e(Q)">>, + + <<"L = [{1,a},{2,b},{3,c}], + Q = qlc:q( % X imported + [{X,qlc:e(qlc:q([{X,Y} || {Y,_} <- qlc_SUITE:table(L, []), + Y > X]))} || + {X,_} <- qlc_SUITE:table(L, [])]), + true = binary_to_list(<< + \"qlc:q([{X,qlc:e(qlc:q([{X,Y}||{Y,_}<-qlc_SUITE:table(L,[]),\" + \"Y>X]))}||{X,_}<-qlc_SUITE:the_list([{1,a},{2,b},{3,c}])])\">>) + == format_info(Q, true), + [{1,[{1,2},{1,3}]},{2,[{2,3}]},{3,[]}] = qlc:e(Q)">>, + + <<"L = [{1,a},{2,b},{3,c}], + Q = qlc:q( + [{X,R} || + {X,_} <- qlc_SUITE:table(L, []), + begin % X imported + R = qlc:e(qlc:q([{X,Y} || {Y,_} + <- qlc_SUITE:table(L, []), + Y =:= X])), + true + end]), + true = binary_to_list(<< + \"qlc:q([{X,R}||{X,_}<-qlc_SUITE:the_list([{1,a},{2,b},{3,c}]),\" + \"beginR=qlc:e(qlc:q([{X,Y}||{Y,_}<-qlc_SUITE:table(L,[]),\" + \"Y=:=X])),trueend])\">>) == format_info(Q, true), + [{1,[{1,1}]},{2,[{2,2}]},{3,[{3,3}]}] = qlc:e(Q)">>, + + <<"L = [{1,a},{2,b},{3,c}], + Q = qlc:q( + [{X, % X imported + qlc:e(qlc:q([{X,Y} || {Y,_} <- qlc_SUITE:table(L, []), + Y =:= X]))} || + {X,_} <- qlc_SUITE:table(L, [])]), + true = binary_to_list(<< + \"qlc:q([{X,qlc:e(qlc:q([{X,Y}||{Y,_}<-qlc_SUITE:table(L,[]),\" + \"Y=:=X]))}||{X,_}<-qlc_SUITE:the_list([{1,a},{2,b},{3,c}])])\">>) + == format_info(Q, true), + [{1,[{1,1}]},{2,[{2,2}]},{3,[{3,3}]}] = qlc:e(Q)">>, + + <<"L = [{1,a},{2,b},{3,c}], + Q = qlc:q( + [{X,R} || + {X,_} <- qlc_SUITE:table(L, []), + begin + R = qlc:e(qlc:q([Y || Y <- [X]])), + true + end]), + true = binary_to_list(<< + \"qlc:q([{X,R}||{X,_}<-qlc_SUITE:the_list([{1,a},{2,b},{3,c}]),\" + \"beginR=qlc:e(qlc:q([Y||Y<-[X]])),trueend])\">>) + == format_info(Q, true), + [{1,[1]},{2,[2]},{3,[3]}] = qlc:e(Q)">>, + + <<"L = [{1,a},{2,b},{3,c}], + Q = qlc:q( + [{X,qlc:e(qlc:q([Y || Y <- [X]]))} || + {X,_} <- qlc_SUITE:table(L, [])]), + true = binary_to_list(<< + \"qlc:q([{X,qlc:e(qlc:q([Y||Y<-[X]]))}||{X,_}<-qlc_SUITE:\" + \"the_list([{1,a},{2,b},{3,c}])])\">>) == format_info(Q, true), + [{1,[1]},{2,[2]},{3,[3]}] = qlc:e(Q)">>, + + <<"L = [{1,a},{2,b}], + Q = qlc:q( + [{X,Y} || + {X,_} <- qlc_SUITE:table(L, []), + {Y,_} <- qlc:q( + [{Z,V} || + {Z,_} <- qlc_SUITE:table(L, []), + {V} <- qlc:q( + [{W} || W + <- qlc_SUITE:table(L, [])]) + ]) + ]), + true = binary_to_list(<< + \"beginV1=qlc:q([{W}||W<-qlc_SUITE:the_list([{1,a},{2,b}])]),\" + \"V2=qlc:q([{Z,V}||{Z,_}<-qlc_SUITE:the_list([{1,a},{2,b}]),\" + \"{V}<-V1]),qlc:q([{X,Y}||{X,_}<-qlc_SUITE:the_list([{1,a},\" + \"{2,b}]),{Y,_}<-V2])end\">>) == format_info(Q, true), + [{1,1},{1,1},{1,2},{1,2},{2,1},{2,1},{2,2},{2,2}] = qlc:e(Q)">> + + ], + ?line run(Config, Ts), + ok. + + +lookup1(doc) -> + "Lookup keys. Mostly test of patterns."; +lookup1(suite) -> []; +lookup1(Config) when is_list(Config) -> + Ts = [ + <<"etsc(fun(E) -> + Q = qlc:q([A || {A=3} <- ets:table(E)]), + [3] = qlc:eval(Q), + [3] = lookup_keys(Q) + end, [{1},{2},{3},{4}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([A || {A=3} <- ets:table(E)],{max_lookup,0}), + [3] = qlc:eval(Q), + false = lookup_keys(Q) + end, [{1},{2},{3},{4}])">>, + + <<"%% The lookup and max_lookup options interact. + etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + (X =:= 1) or (X =:= 2)], + [{lookup,true},{max_lookup,1}]), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch qlc:e(Q)) + end, [{1},{2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,C,D} || {A,B}={C,D} <- ets:table(E)]), + [{1,2,1,2},{3,4,3,4}] = lists:sort(qlc:eval(Q)), + false = lookup_keys(Q) + end, [{1,2},{3,4}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,D} || {A,B}={D,A} <- ets:table(E)]), + [{1,1,1},{2,2,2}] = lists:sort(qlc:eval(Q)), + false = lookup_keys(Q) + end, [{1,2},{2,2},{1,1}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,D} || {A,B}={D,A} <- ets:table(E), + (D =:= 2) or (B =:= 1)], + {max_lookup,infinity}), + [{1,1,1},{2,2,2}] = qlc:eval(Q), + [1,2] = lookup_keys(Q) + end, [{1,2},{2,2},{1,1}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,D} || {A,B}={D,A} <- ets:table(E), + (D =:= 2) xor (B =:= 1)]), + [{1,1,1},{2,2,2}] = qlc:eval(Q), + [1,2] = lookup_keys(Q) + end, [{1,2},{2,2},{1,1}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([3 || {{[3,4],apa}} <- ets:table(E)]), + [3] = qlc:e(Q), + [{[3,4],apa}] = lookup_keys(Q) + end, [{{[4,3],foo}},{{[3,4],apa}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([3 || {3} <- ets:table(E)]), + [3] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{2},{3},{4}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y,Z} || {{X,_},Y,Y={_,Z},X,Y} <- ets:table(E)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{{1,1},1,{1,1},1,1}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,X=2} <- ets:table(E)]), + [2] = qlc:e(Q), + [2] = lookup_keys(Q) + end, [{2,2},{3,3}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{_,3}={4,_}=X} <- ets:table(E)]), + [{4,3}] = qlc:e(Q), + [{4,3}] = lookup_keys(Q) + end, [{{2,3}},{{4,3}}])">>, + + <<"U = 17.0, + etsc(fun(E) -> + Q = qlc:q([X || {_=X=_} <- ets:table(E)]), + [U] = qlc:e(Q), + false = lookup_keys(Q) + end, [{U},{U+U,U}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y,Z,W} || {X=Y}=Z={V=W} <- ets:table(E), + V == {h,g}]), + [{{h,g},{h,g},{{h,g}},{h,g}}] = qlc:e(Q), + [{h,g}] = lookup_keys(Q) + end, [{h,g},{{h,g}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{C,Y,Z,X} || {{X=Y}=Z}={{A=B}=C} <- ets:table(E), + A == a, B =/= c]), + [{{a},a,{a},a}] = qlc:e(Q), + [{a}] = lookup_keys(Q) + end, [{{1}},{{a}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,D,Y,X} || + {{A={B=C}},{D={C}}} = {X,Y} <- ets:table(E), + [] == B]), + [{{[]},{[]},{{[]}},{{[]}}}] = qlc:e(Q), + [{{[]}}] = lookup_keys(Q) + end, [{{{[]}},{{[]}}}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X}=X <- ets:table(E)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1},{a}])">>, + {warnings,[{{2,37},qlc,nomatch_pattern}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X=X,Y=Y}={Y=Y,X=X} <- ets:table(E), + {} == X]), + [{}] = qlc:e(Q), + [{}] = lookup_keys(Q) + end, [{{},{}},{[],[]}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {3+4=7,X} <- ets:table(E), + X =:= 3+997]), + [1000] = qlc:e(Q), + [7] = lookup_keys(Q) + end, [{7,1000},{8,1000}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{X, Y} || [X]=[Y] <- ets:table(E)]), + [] = qlc:eval(Q), + false = lookup_keys(Q) + end, [{a}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || X={1,2,3,X,5} <- ets:table(E)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{a},{b}])">>, + {warnings,[{{2,35},qlc,nomatch_pattern}]}}, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || X=[1,2,3,X,5] <- ets:table(E)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{a},{b}])">>, + {warnings,[{{2,35},qlc,nomatch_pattern}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([X || X = <<X>> <- ets:table(E)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{a},{b}])">>, + + <<"Tre = 3.0, + etsc(fun(E) -> + Q = qlc:q([{A,B} || {A,B}={{a,C},{a,C}} <- ets:table(E), + C =:= Tre]), + [] = qlc:e(Q), + [{a,Tre}] = lookup_keys(Q) + end, [{a,b}])">>, + + <<"A = 3, + etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), A =:= element(1, X)]), + [{3,3}] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{1,a},{3,3}])">>, + + <<"A = 3, + etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), A =:= erlang:element(1, X)]), + [{3,3}] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{1,a},{3,3}])">>, + + <<"A = 3, + etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), A =:= {erlang,element}(1, X)]), + [{3,3}] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{1,a},{3,3}])">>, + + <<"etsc(fun(E) -> + A = 3, + Q = qlc:q([X || X <- ets:table(E), + A == element(1,X), + element(1,X) =:= a]), + [] = qlc:e(Q), + [a] = lookup_keys(Q) + end, [{a},{b},{c}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X = {[a,Z]}, + Z = [foo, {[Y]}], + Y = {{foo,[X]}}} <- ets:table(E)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{a,b,c},{d,e,f}])">>, + {warnings,[{{2,34},qlc,nomatch_pattern}]}} + + ], + ?line run(Config, Ts), + ok. + +lookup2(doc) -> + "Lookup keys. Mostly test of filters."; +lookup2(suite) -> []; +lookup2(Config) when is_list(Config) -> + Ts = [ + <<"%% Only guards are inspected. No lookup. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X,Y} <- ets:table(E), + ((Y = X) =:= 3)]), + {'EXIT', {{badmatch,4},_}} = (catch qlc:e(Q)) + end, [{3,3},{4,true}])">>, + + <<"%% Only guards are inspected. No lookup. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X,Y} <- ets:table(E), + Y = (X =:= 3)]), + {'EXIT', {{badmatch,false},_}} = (catch qlc:e(Q)) + end, [{false,3},{true,3}])">>, + + <<"%% Only guards are inspected. No lookup. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X,Y} <- ets:table(E), + Y = (X =:= 3)]), + {'EXIT', {{badmatch,false},_}} = (catch qlc:e(Q)) + end, [{3,true},{4,true}])">>, + + <<"%% Only guards are inspected. No lookup. + E1 = create_ets(1, 10), + E2 = ets:new(join, []), + true = ets:insert(E2, [{true,1},{false,2}]), + Q = qlc:q([{X,Z} || {_,X} <- ets:table(E1), + {Y,Z} <- ets:table(E2), + Y = (X =:= 3)]), + {'EXIT', {{badmatch,false},_}} = (catch qlc:e(Q)), + ets:delete(E1), + ets:delete(E2)">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,D} || {A,B}={D,A} <- ets:table(E), + (A =:= 3) or (4 =:= D)]), + [{3,3,3},{4,4,4}] = lists:sort(qlc:e(Q)), + [3,4] = lookup_keys(Q) + end, [{2,2},{3,3},{4,4}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,U} <- ets:table(E), X =:= U]), + [1] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1,1}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X=Y} <- ets:table(E), + {[X],4} =:= {[3],X}]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1}, {2}])">>, + {warnings,[{{3,46},qlc,nomatch_filter}]}}, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X == 1, X =:= 2]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1}, {2}])">>, + {warnings,[{{3,43},qlc,nomatch_filter}]}}, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X=Y} <- ets:table(E), + {[X,Y],4} =:= {[3,X],X}]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1}, {2}])">>, + {warnings,[{{3,48},qlc,nomatch_filter}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X,Y} <- ets:table(E), + ({X,3} =:= {Y,Y}) or (X =:= 4)]), + [{3,3},{4,4}] = lists:sort(qlc:e(Q)), + [3,4] = lookup_keys(Q) + end, [{2,2},{3,3},{4,4},{5,5}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), {[X]} =:= {[3,4]}]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{[3]},{[3,4]}])">>, + {warnings,[{{2,61},qlc,nomatch_filter}]}}, + + <<"etsc(fun(E) -> + U = 18, + Q = qlc:q([{X,Y} || {X=Y} <- ets:table(E), [X|a] =:= [3|U]]), + [] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{2}, {3}])">>, + + <<"etsc(fun(E) -> + U = 18, V = 19, + Q = qlc:q([{X,Y} || {X=Y} <- ets:table(E), + [X|V] =:= [3|U+1]]), + [{3,3}] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{2},{3}])">>, + + <<"%% Blocks are not handled. + etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), begin X == a end]), + [a] = qlc:e(Q), + false = lookup_keys(Q) + end, [{a},{b}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + (3 =:= X) or (X =:= 12), + (8 =:= X) or (X =:= 10)]), + [] = lists:sort(qlc:e(Q)), + false = lookup_keys(Q) + end, [{2},{3},{4},{8}])">>, + {warnings,[{{4,44},qlc,nomatch_filter}]}}, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + ((3 =:= X) or (X =:= 12)) + and ((8 =:= X) or (X =:= 10))]), + [] = lists:sort(qlc:e(Q)), + false = lookup_keys(Q) + end, [{2},{3},{4},{8}])">>, + {warnings,[{{4,35},qlc,nomatch_filter}]}}, + + <<"F = fun(U) -> + Q = qlc:q([X || {X} <- [a,b,c], + X =:= if U -> true; true -> false end]), + [] = qlc:eval(Q), + false = lookup_keys(Q) + end, + F(apa)">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X=1,X} <- ets:table(E), X =:= 2]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1,1},{2,1}])">>, + {warnings,[{{2,61},qlc,nomatch_filter}]}}, + + <<"Two = 2.0, + etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), X =:= Two]), + [Two] = qlc:e(Q), + [Two] = lookup_keys(Q) + end, [{2.0},{2}])">>, + + <<"etsc(fun(E) -> + %% This float is equal (==) to an integer. Not a constant! + Q = qlc:q([X || {X} <- ets:table(E), X == {a,b,c,[2.0]}]), + [_,_] = qlc:e(Q), + false = lookup_keys(Q) + end, [{{a,b,c,[2]}},{{a,b,c,[2.0]}}])">>, + + <<"%% Must _not_ regard floats as constants. Check imported variables + %% in runtime. + etsc(fun(E) -> + U = 3.0, + QH = qlc:q([X || {X,_} <- ets:table(E), X =:= U]), + [] = qlc:e(QH), + [U] = lookup_keys(QH) + end, [{1,a},{2,b},{3,c},{4,d}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + length(X) =:= 1]), + [[1]] = qlc:e(Q), + false = lookup_keys(Q) + end, [{[1]},{[2,3]}])">>, + + <<"etsc(fun(E) -> + A=3, + Q = qlc:q([X || {X,Y} <- ets:table(E), X =:= A, Y =:= 3]), + [3] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{3,3},{4,3}])">>, + + <<"etsc(fun(E) -> + A = 1, + Q = qlc:q([X || {X} <- ets:table(E), + X =:= 1, <<X>> =:= <<A>>]), + [1] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1},{2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), X == a]), + [a] = qlc:e(Q), + [a] = lookup_keys(Q) + end, [{a},{b},{c}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X}=Y <- ets:table(E), + element(2, Y) == b, + X =:= 1]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1,b},{2,3}])">>, + {warnings,[{{3,48},qlc,nomatch_filter}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), element(1,{X}) =:= 1]), + [1] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1}, {2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), 1 =:= element(1,{X})]), + [1] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1}, {2}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X =:= {1}, + element(1,X) =:= 2]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{{1}},{{2}}])">>, + {warnings,[{{4,47},qlc,nomatch_filter}]}}, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X =:= {1}, + element(1,X) =:= element(1, {2})]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{{1}},{{2}}])">>, + {warnings,[{{4,47},qlc,nomatch_filter}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + element(1,X) =:= 1, X =:= {1}]), + [{1}] = qlc:e(Q), + [{1}] = lookup_keys(Q) + end, [{{1}},{{2}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + {{element(1,element(1,{{1}}))}} =:= {X}]), + [{1}] = qlc:e(Q), + [{1}] = lookup_keys(Q) + end, [{{1}},{{2}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), + {element(1,element(1, {{1}}))} =:= + {element(1,X)}]), + [{1}] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1},{2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,Y}} <- ets:table(E), + (X =:= 1) and (Y =:= 2) + or (X =:= 3) and (Y =:= 4)]), + [1,3] = lists:sort(qlc:e(Q)), + [{1,2}, {3,4}] = lookup_keys(Q) + end, [{{1,2}}, {{3,4}}, {{2,3}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,a}} <- ets:table(E), X =:= 3]), + [3] = qlc:e(Q), + [{3,a}] = lookup_keys(Q) + end, [{{3,a}},{{3,b}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,Y},_Z} <- ets:table(E), + X =:= 3, Y =:= a]), + [3] = qlc:e(Q), + [{3,a}] = lookup_keys(Q) + end, [{{3,a},3}, {{4,a},3}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,Y},_Z} <- ets:table(E), + (X =:= 3) and (Y =:= a) + or (X =:= 4) and (Y =:= a)]), + [3,4] = qlc:e(Q), + [{3,a}, {4,a}] = lookup_keys(Q) + end, [{{3,a},3}, {{4,a},3}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + (X =:= 3) and (X =:= a)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{3}, {4}])">>, + {warnings,[{{3,44},qlc,nomatch_filter}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,Y}} <- ets:table(E), + X =:= 3, ((Y =:= a) or (Y =:= b))]), + [3,3] = qlc:e(Q), + [{3,a},{3,b}] = lists:sort(lookup_keys(Q)) + end, [{{3,a}},{{2,b}},{{3,b}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,Y} <- ets:table(E), + ((X =:= 3) or (Y =:= 4)) and (X == a)]), + [a] = qlc:e(Q), + [a] = lookup_keys(Q) + end, [{a,4},{3,3}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,Y} <- ets:table(E), + (X =:= 3) or ((Y =:= 4) and (X == a))]), + [3,a] = lists:sort(qlc:e(Q)), + [3,a] = lookup_keys(Q) + end, [{a,4},{3,3}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,Y}} <- ets:table(E), + (X =:= 3) or ((Y =:= 4) and (X == a))]), + [3,a] = lists:sort(qlc:e(Q)), + false = lookup_keys(Q) + end, [{{3,a}},{{2,b}},{{a,4}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {{X,Y}} <- ets:table(E), + ((X =:= 3) or (Y =:= 4)) and (X == a)]), + [a] = lists:sort(qlc:e(Q)), + [{a,4}] = lookup_keys(Q) + end, [{{3,a}},{{2,b}},{{a,4}}])">>, + + <<"etsc(fun(E) -> + NoAnswers = 3*3*3+2*2*2, + Q = qlc:q([{X,Y,Z} || + {{X,Y,Z}} <- ets:table(E), + (((X =:= 4) or (X =:= 5)) and + ((Y =:= 4) or (Y =:= 5)) and + ((Z =:= 4) or (Z =:= 5))) or + (((X =:= 1) or (X =:= 2) or (X =:= 3)) and + ((Y =:= 1) or (Y =:= 2) or (Y =:= 3)) and + ((Z =:= 1) or (Z =:= 2) or (Z =:= 3)))], + {max_lookup, NoAnswers}), + {list, {table, _}, _} = i(Q), + [{1,1,1},{2,2,2},{3,3,3}] = lists:sort(qlc:e(Q)), + true = NoAnswers =:= length(lookup_keys(Q)) + end, [{{1,1,1}},{{2,2,2}},{{3,3,3}},{{3,3,4}},{{4,1,1}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y,Z} || + {{X,Y,Z}} <- ets:table(E), + (((X =:= 4) or (X =:= 5)) and + ((Y =:= 4) or (Y =:= 5)) and + ((Z =:= 4) or (Z =:= 5))) or + (((X =:= 1) or (X =:= 2) or (X =:= 3)) and + ((Y =:= 1) or (Y =:= 2) or (Y =:= 3)) and + ((Z =:= 1) or (Z =:= 2) or (Z =:= 3)))], + {max_lookup, 10}), + [{1,1,1},{2,2,2},{3,3,3}] = lists:sort(qlc:e(Q)), + {table,{ets,table,[_,[{traverse,{select,_}}]]}} = i(Q) + end, [{{1,1,1}},{{2,2,2}},{{3,3,3}},{{3,3,4}},{{4,1,1}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || X={_,_,_} <- ets:table(E), + element(1, X) =:= 3, element(2, X) == a]), + [{3,a,s}] = qlc:e(Q), + [3] = lookup_keys(Q) + end, [{1,c,q},{2,b,r},{3,a,s}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), + element(0, X) =:= 3]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1},{2}])">>, + + <<"etsc(fun(E) -> + F = fun(_) -> 3 end, + %% No occurs check; X =:= F(X) is ignored. + Q = qlc:q([X || {X} <- ets:table(E), + X =:= 3, X =:= F(X)]), + {qlc,_,[{generate,_,{list,{table,_},_}},_],[]} = i(Q), + [3] = lists:sort(qlc:e(Q)), + [3] = lookup_keys(Q) + end, [{2},{3},{4}])">>, + + <<"etsc(fun(E) -> + A = a, B = a, + Q = qlc:q([X || {{X,Y}} <- ets:table(E), + ((X =:= A) and (Y =:= B)) + or ((X =:= B) and (Y =:= A))]), + [a] = qlc:e(Q), + %% keys are usorted, duplicate removed: + [{a,a}] = lookup_keys(Q) + end, [{{a,a}},{{b,b}}])">>, + + <<"etsc(fun(E) -> + A = a, B = b, + Q = qlc:q([X || {{X,Y}} <- ets:table(E), + ((X =:= A) and (Y =:= B)) + or ((X =:= B) and (Y =:= A))]), + [a,b] = lists:sort(qlc:e(Q)), + [{a,b},{b,a}] = lookup_keys(Q) + end, [{{a,b}},{{b,a}},{{c,a}},{{d,b}}])">>, + + %% The atom 'fail' is recognized - lookup. + <<"etsc(fun(E) -> + Q = qlc:q([A || {A} <- ets:table(E), + (A =:= 2) + orelse fail + ]), + [2] = lists:sort(qlc:e(Q)), + [2] = lookup_keys(Q) + end, [{1},{2}])">> + + ], + ?line run(Config, Ts), + + TsR = [ + %% is_record/2,3: + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + erlang:is_record(X, r, 2)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + is_record(X, r, 2)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + {erlang,is_record}(X, r, 2)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">>, + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + record(X, r)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">>, + {warnings,[{{4,45},erl_lint,{obsolete_guard,{record,2}}}]}}, + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + erlang:is_record(X, r)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + is_record(X, r)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([element(1, X) || X <- ets:table(E), + {erlang,is_record}(X, r)]), + [r] = qlc:e(Q), + [r] = lookup_keys(Q) + end, [{keypos,1}], [#r{}])">> + + ], + ?line run(Config, <<"-record(r, {a}).\n">>, TsR), + + Ts2 = [ + <<"etsc(fun(E) -> + Q0 = qlc:q([X || + X <- ets:table(E), + (element(1, X) =:= 1) or + (element(1, X) =:= 2)], + {cache,ets}), + Q = qlc:q([{X,Y} || + X <- [1,2], + Y <- Q0]), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{table,_}}], []} = i(Q), + [{1,{1}},{1,{2}},{2,{1}},{2,{2}}] = lists:sort(qlc:e(Q)), + [1,2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2}])">>, + + <<"etsc(fun(E) -> + Q0 = qlc:q([X || + X <- ets:table(E), + (element(1, X) =:= 1) or + (element(1, X) =:= 2)]), + Q = qlc:q([{X,Y} || + X <- [1,2], + Y <- Q0], + {cache,true}), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{table,_}}],[]} = i(Q), + [1,2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2}])">>, + + %% One introduced QLC expression (join, ms), and the cache option. + <<"%% Match spec and lookup. The lookup is done twice, which might + %% be confusing... + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + {Y} <- ets:table(E), + (Y =:= 1) or (Y =:= 2)], + []), + [{1,1},{1,2},{2,1},{2,2}] = qlc:e(Q), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{list,{table,_},_}}],[]} = i(Q), + [1,2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + <<"%% The same as last example, but with cache. + %% No cache needed (always one lookup only). + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + {Y} <- ets:table(E), + (Y =:= 1) or (Y =:= 2)], + [cache]), + [{1,1},{1,2},{2,1},{2,2}] = qlc:e(Q), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{list,{table,_},_}}],[]} = i(Q), + [1,2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + + <<"%% And again, this time only lookup, no mach spec. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + Y <- ets:table(E), + (element(1, Y) =:= 1) + or (element(1, Y) =:= 2)], + []), + [{1,{1}},{1,{2}},{2,{1}},{2,{2}}] = qlc:e(Q), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{table,_}}],[]} = i(Q), + [1,2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + <<"%% As last one, but with cache. + %% No cache needed (always one lookup only). + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + Y <- ets:table(E), + (element(1, Y) =:= 1) + or (element(1, Y) =:= 2)], + [cache]), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{table,_}}],[]} = i(Q), + [{1,{1}},{1,{2}},{2,{1}},{2,{2}}] = qlc:e(Q), + [1,2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + + <<"%% Lookup only. No cache. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + {Y=2} <- ets:table(E)], + []), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{table,_}}],[]} = i(Q), + [{1,2},{2,2}] = qlc:e(Q), + [2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + <<"%% Lookup only. No cache. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + {Y=2} <- ets:table(E)], + [cache]), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{table,_}}],[]} = i(Q), + [{1,2},{2,2}] = qlc:e(Q), + [2] = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + + <<"%% Matchspec only. No cache. + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + {Y} <- ets:table(E), + Y > 1], + []), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_, + {table,{ets,_,[_,[{traverse,_}]]}}}],[]} = + i(Q), + [{1,2},{1,3},{2,2},{2,3}] = qlc:e(Q), + false = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + <<"%% Matchspec only. Cache + etsc(fun(E) -> + Q = qlc:q([{X,Y} || + X <- [1,2], + {Y} <- ets:table(E), + Y > 1], + [cache]), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{qlc,_, + [{generate,_,{table,{ets,_,[_,[{traverse,_}]]}}}], + [{cache,ets}]}}],[]} = i(Q), + [{1,2},{1,3},{2,2},{2,3}] = qlc:e(Q), + false = lookup_keys(Q) + end, [{keypos,1}], [{1},{2},{3}])">>, + <<"%% An empty list. Always unique and cached. + Q = qlc:q([X || {X} <- [], X =:= 1, begin X > 0 end], + [{cache,true},{unique,true}]), + {qlc,_,[{generate,_,{list,[]}},_],[{unique,true}]} = i(Q), + _ = qlc:info(Q), + [] = qlc:e(Q)">>, + <<"%% A list is always cached. + Q = qlc:q([{X,Y} || Y <- [1,2], X <- [2,1,2]], + [cache]), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{list,[2,1,2]}}],[]} = i(Q), + [{2,1},{1,1},{2,1},{2,2},{1,2},{2,2}] = qlc:e(Q)">>, + <<"%% But a processed list is never cached. + Q = qlc:q([{X,Y} || Y <- [1,2], X <- [2,1,2], X > 1], + [cache]), + {qlc,_,[{generate,_, {list,[1,2]}}, + {generate,_,{qlc,_, + [{generate,_,{list,{list,[2,1,2]},_}}], + [{cache,ets}]}}],[]} = i(Q), + [{2,1},{2,1},{2,2},{2,2}] = qlc:e(Q)">>, + <<"%% A bug fixed in R11B-2: coalescing simple_qlc:s works now. + Q0 = qlc:q([X || {X} <- [{1},{2},{3}]], {cache, ets}), + Q1 = qlc:q([X || X <- Q0], {cache, list}), + Q = qlc:q([{Y,X} || Y <- [1,2], X <- Q1, X < 2], {cache, list}), + {qlc,_,[{generate,_,{list,_}}, + {generate,_,{qlc,_,[{generate,_,{list,{list,_},_}}], + [{cache,ets}]}},_],[]} = i(Q), + [{1,1},{2,1}] = qlc:e(Q)">>, + <<"Q = qlc:q([{X,Y} || Y <- [1,2], X <- [1,2], X > 1], + [cache,unique]), + {qlc,_,[{generate,_,{list,[1,2]}}, + {generate,_,{qlc,_, + [{generate,_,{list,{list,[1,2]},_}}], + [{cache,ets},{unique,true}]}}], + [{unique,true}]} = i(Q), + [{2,1},{2,2}] = qlc:e(Q)">>, + <<"L = [1,2,3], + QH1 = qlc:q([{X} || X <- L, X > 1]), + QH2 = qlc:q([{X} || X <- QH1, X > 0], [cache]), + [{{2}},{{3}}] = qlc:e(QH2), + {list,{list,{list,L},_},_} = i(QH2)">>, + <<"L = [1,2,3,1,2,3], + QH1 = qlc:q([{X} || X <- L, X > 1]), + QH2 = qlc:q([{X} || X <- QH1, X > 0], [cache,unique]), + [{{2}},{{3}}] = qlc:e(QH2), + {qlc,_,[{generate,_,{list,{list,{list,L},_},_}}], + [{unique,true}]} = i(QH2)">> + + ], + + ?line run(Config, Ts2), + + LTs = [ + <<"etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), + element(1, X) =:= 1], + {lookup,true}), + {table,L} = i(Q), + true = is_list(L), + [{1,a}] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1,a},{2,b}])">>, + <<"%% No lookup, use the match spec for traversal instead. + etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), + element(1, X) =:= 1], + {lookup,false}), + {table,{ets,table,_}} = i(Q), + [{1,a}] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1,a},{2,b}])">>, + <<"%% As last one. {max_lookup,0} has the same effect. + etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), + element(1, X) =:= 1], + {max_lookup,0}), + {table,{ets,table,_}} = i(Q), + [{1,a}] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1,a},{2,b}])">> + + ], + ?line run(Config, LTs), + + ok. + +lookup_rec(doc) -> + "Lookup keys. With records."; +lookup_rec(suite) -> []; +lookup_rec(Config) when is_list(Config) -> + Ts = [ + <<"etsc(fun(E) -> + Q = qlc:q([A || #r{a = A} <- ets:table(E), + (A =:= 3) or (4 =:= A)]), + [3] = qlc:e(Q), + [3,4] = lookup_keys(Q) + end, [{keypos,2}], [#r{a = a}, #r{a = 3}, #r{a = 5}])">>, + + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([A || #r{a = 17 = A} <- ets:table(E), + (A =:= 3) or (4 =:= A)]), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{keypos,2}], [#r{a = 17}, #r{a = 3}, #r{a = 5}])">>, + {warnings,[{{4,44},qlc,nomatch_filter}]}}, + + <<"%% Compares an integer and a float. + etsc(fun(E) -> + Q = qlc:q([A || #r{a = 17 = A} <- ets:table(E), + (A == 17) or (17.0 == A)]), + [_] = qlc:e(Q), + [_] = lookup_keys(Q) + end, [{keypos,2}], [#r{a = 17}, #r{a = 3}, #r{a = 5}])">>, + + <<"%% Compares an integer and a float. + %% There is a test in qlc_pt.erl (Op =:= '=:=', C1 =:= C2), but + %% that case is handled in an earlier clause (unify ... E, E). + etsc(fun(E) -> + Q = qlc:q([A || #r{a = 17.0 = A} <- ets:table(E), + (A =:= 17) or (17.0 =:= A)]), + [_] = qlc:e(Q), + [_] = lookup_keys(Q) + end, [{keypos,2}], [#r{a = 17.0}, #r{a = 3}, #r{a = 5}])">>, + + <<"%% Matches an integer and a float. + etsc(fun(E) -> + Q = qlc:q([A || #r{a = 17 = A} <- ets:table(E), + (A =:= 17) or (17.0 =:= A)]), + [_] = qlc:e(Q), + [_] = lookup_keys(Q) + end, [{keypos,2}], [#r{a = 17}, #r{a = 3}, #r{a = 5}])">>, + + <<"etsc(fun(E) -> + F = fun(_) -> 17 end, + Q = qlc:q([A || #r{a = A} <- ets:table(E), + (F(A) =:= 3) and (A =:= 4)]), + [] = qlc:e(Q), + false = lookup_keys(Q) % F(A) could fail + end, [{keypos,2}], [#r{a = 4}, #r{a = 3}, #r{a = 5}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + #r{} == X]), + [#r{}] = lists:sort(qlc:e(Q)), + {call,_,_,[_,_]} = i(Q, {format, abstract_code}), + [#r{}] = lookup_keys(Q) + end, [{#r{}},{#r{a=foo}}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([R#r.a || R <- ets:table(E), R#r.a =:= foo]), + [foo] = qlc:e(Q), + [_] = lookup_keys(Q) + end, [{keypos,2}], [#r{a=foo}])">> + ], + ?line run(Config, <<"-record(r, {a}).\n">>, Ts), + ok. + +indices(doc) -> + "Using indices for lookup."; +indices(suite) -> []; +indices(Config) when is_list(Config) -> + Ts = [ + <<"L = [{1,a},{2,b},{3,c}], + QH = qlc:q([element(1, X) || X <- qlc_SUITE:table(L, [2]), + (element(2, X) =:= a) + or (b =:= element(2, X))]), + {list, {table,{qlc_SUITE,list_keys,[[a,b],2,L]}}, _MS} = i(QH), + [1,2] = qlc:eval(QH)">>, + + <<"L = [{1,a},{2,b},{3,c}], + QH = qlc:q([element(1, X) || X <- qlc_SUITE:table(L, [2]), + begin (element(2, X) =:= a) + or (b =:= element(2, X)) end]), + {qlc,_,[{generate,_,{table,{call,_, + {remote,_,_,{atom,_,the_list}},_}}},_],[]} + = i(QH), + [1,2] = qlc:eval(QH)">>, + + <<"L = [{1,a,q},{2,b,r},{3,c,s}], + QH = qlc:q([element(1, X) || X <- qlc_SUITE:table(L, [2,3]), + (element(3, X) =:= q) + or (r =:= element(3, X))]), + {list, {table,{qlc_SUITE,list_keys, [[q,r],3,L]}}, _MS} = i(QH), + [1,2] = qlc:eval(QH)">>, + + <<"L = [{1,a,q},{2,b,r},{3,c,s}], + QH = qlc:q([element(1, X) || X <- qlc_SUITE:table(L, 1, [2]), + (element(3, X) =:= q) + or (r =:= element(3, X))]), + {qlc,_,[{generate,_,{table,{call,_,_,_}}}, + _],[]} = i(QH), + [1,2] = qlc:eval(QH)">>, + + <<"L = [{a,1},{b,2},{c,3}], + QH = qlc:q([E || {K,I}=E <- qlc_SUITE:table(L, 1, [2]), + ((K =:= a) or (K =:= b) or (K =:= c)) + and ((I =:= 1) or (I =:= 2))], + {max_lookup, 3}), + {list, {table,{qlc_SUITE,list_keys,[[a,b,c],1,L]}}, _MS} = i(QH), + [{a,1},{b,2}] = qlc:eval(QH)">>, + + <<"L = [{a,1},{b,2},{c,3}], + QH = qlc:q([E || {K,I}=E <- qlc_SUITE:table(L, 1, [2]), + ((K =:= a) or (K =:= b) or (K =:= c)) + and ((I =:= 1) or (I =:= 2))], + {max_lookup, 2}), + {list, {table,{qlc_SUITE,list_keys, [[1,2],2,L]}}, _MS} = i(QH), + [{a,1},{b,2}] = qlc:eval(QH)">>, + + <<"L = [{a,1,x,u},{b,2,y,v},{c,3,z,w}], + QH = qlc:q([E || {K,I1,I2,I3}=E <- qlc_SUITE:table(L, 1, [2,3,4]), + ((K =/= a) or (K =/= b) or (K =/= c)) + and ((I1 =:= 1) or (I1 =:= 2) or + (I1 =:= 3) or (I1 =:= 4)) + and ((I2 =:= x) or (I2 =:= z)) + and ((I3 =:= v) or (I3 =:= w))], + {max_lookup, 5}), + {list, {table,{qlc_SUITE,list_keys, [[x,z],3,L]}}, _MS} = i(QH), + [{c,3,z,w}] = qlc:eval(QH)">> + + ], + ?line run(Config, <<"-record(r, {a}).\n">>, Ts), + ok. + +pre_fun(doc) -> + "Test the table/2 callback functions parent_fun and stop_fun."; +pre_fun(suite) -> []; +pre_fun(Config) when is_list(Config) -> + Ts = [ + <<"PF = process_flag(trap_exit, true), + %% cursor: table killing parent + L = [{1,a},{2,b},{3,c}], + F1 = fun() -> + QH = qlc:q([element(1, X) || + X <- qlc_SUITE:table_kill_parent(L, [2]), + (element(2, X) =:= a) + or (b =:= element(2, X))]), + _ = qlc:info(QH), + _ = qlc:cursor(QH) + end, + Pid1 = spawn_link(F1), + receive {'EXIT', Pid1, killed} -> + ok + end, + timer:sleep(1), + process_flag(trap_exit, PF)">>, + + <<"PF = process_flag(trap_exit, true), + %% eval without cursor: table killing parent + L = [{1,a},{2,b},{3,c}], + F2 = fun() -> + QH = qlc:q([element(1, X) || + X <- qlc_SUITE:table_kill_parent(L, [2]), + (element(2, X) =:= a) + or (b =:= element(2, X))]), + _ = qlc:eval(QH) + end, + Pid2 = spawn_link(F2), + receive {'EXIT', Pid2, killed} -> + ok + end, + process_flag(trap_exit, PF)">>, + + <<"L = [{1,a},{2,b},{3,c}], + QH = qlc:q([element(1, X) || + X <- qlc_SUITE:table_parent_throws(L, [2]), + (element(2, X) =:= a) + or (b =:= element(2, X))]), + _ = qlc:info(QH), + {throw,thrown} = (catch {any_term,qlc:cursor(QH)}), + {throw,thrown} = (catch {any_term,qlc:eval(QH)})">>, + + <<"L = [{1,a},{2,b},{3,c}], + QH = qlc:q([element(1, X) || + X <- qlc_SUITE:table_parent_exits(L, [2]), + (element(2, X) =:= a) + or (b =:= element(2, X))]), + _ = qlc:info(QH), + {'EXIT', {badarith,_}} = (catch qlc:cursor(QH)), + {'EXIT', {badarith,_}} = (catch qlc:eval(QH))">>, + + <<"L = [{1,a},{2,b},{3,c}], + QH = qlc:q([element(1, X) || + X <- qlc_SUITE:table_bad_parent_fun(L, [2]), + (element(2, X) =:= a) + or (b =:= element(2, X))]), + {'EXIT', {badarg,_}} = (catch qlc:cursor(QH)), + {'EXIT', {badarg,_}} = (catch qlc:eval(QH))">>, + + <<"%% Very simple test of stop_fun. + Ets = ets:new(apa, [public]), + L = [{1,a},{2,b},{3,c}], + H = qlc:q([X || {X,_} <- qlc_SUITE:stop_list(L, Ets)]), + C = qlc:cursor(H), + [{stop_fun,StopFun}] = ets:lookup(Ets, stop_fun), + StopFun(), + {'EXIT', {{qlc_cursor_pid_no_longer_exists, _}, _}} = + (catch qlc:next_answers(C, all_remaining)), + ets:delete(Ets)">> + + ], + + ?line run(Config, Ts), + ok. + +skip_filters(doc) -> + "Lookup keys. With records."; +skip_filters(suite) -> []; +skip_filters(Config) when is_list(Config) -> + %% Skipped filters + TsS = [ + %% Cannot skip the filter. + <<"etsc(fun(E) -> + H = qlc:q([X || X <- ets:table(E), + (element(1, X) =:= 1) xor (element(1, X) =:= 1)]), + [] = qlc:eval(H), + [1] = lookup_keys(H) + end, [{keypos,1}], [{1},{2}])">>, + + %% The filter can be skipped. Just a lookup remains. + <<"etsc(fun(E) -> + H = qlc:q([X || X <- ets:table(E), + (element(1, X) =:= 1) or (element(1, X) =:= 1)]), + [{1}] = qlc:eval(H), + {table, _} = i(H), + [1] = lookup_keys(H) + end, [{keypos,1}], [{1},{2}])">>, + + %% safe_unify fails on 3 and <<X:32>> + <<"etsc(fun(E) -> + H = qlc:q([X || X <- ets:table(E), + (element(1, X) =:= 1) and (3 =:= <<X:32>>)]), + [] = qlc:eval(H), + [1] = lookup_keys(H) + end, [{keypos,1}], [{1},{2}])">>, + + %% Two filters are skipped. + <<"etsc(fun(E) -> + Q = qlc:q([{B,C,D} || {A={C},B} <- ets:table(E), + (A =:= {1}) or (A =:= {2}), + (C =:= 1) or (C =:= 2), + D <- [1,2]]), + {qlc,_,[{generate,_,{table,_}},{generate,_,{list,[1,2]}}],[]} + = i(Q), + [{1,1,1},{1,1,2},{2,2,1},{2,2,2}] = lists:sort(qlc:eval(Q)), + [{1},{2}] = lookup_keys(Q) + end, [{{1},1},{{2},2},{{3},3}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{B,C} || {A={C},B} <- ets:table(E), + (A =:= {1}) or (A =:= {2}), + (C =:= 1) or (C =:= 2)]), + {qlc,_,[{generate,_,{table,_}}],[]} = i(Q), + [{1,1},{2,2}] = lists:sort(qlc:eval(Q)), + [{1},{2}] = lookup_keys(Q) + end, [{{1},1},{{2},2},{{3},3}])">>, + + %% Lookup. No match spec, no filter. + <<"etsc(fun(E) -> + Q = qlc:q([X || X <- ets:table(E), + element(1, X) =:= 1]), + {table, _} = i(Q), + [{1}] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1},{2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y} || X <- ets:table(E), + element(1, X) =:= 1, + Y <- [1,2]]), + {qlc,_,[{generate,_,{table,_}},{generate,_,{list,_}}],[]} + = i(Q), + [{{1},1},{{1},2}] = lists:sort(qlc:e(Q)), + [1] = lookup_keys(Q) + end, [{1},{2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,Y} <- ets:table(E), + X =:= a, + X =:= Y]), + {list,{table,_},_} = i(Q), + [a] = qlc:e(Q), + [a] = lookup_keys(Q) + end, [{a,a},{b,c},{c,a}])">>, + + %% The imported variable (A) is never looked up in the current + %% implementation. This means that the first filter cannot be skipped; + %% the constant 'a' is looked up, and then the first filter evaluates + %% to false. + <<"etsc(fun(E) -> + A = 3, + Q = qlc:q([X || X <- ets:table(E), + A == element(1,X), + element(1,X) =:= a]), + [] = qlc:e(Q), + [a] = lookup_keys(Q) + end, [{a},{b},{c}])">>, + + %% No lookup. + {cres, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X =:= 1, + X =:= 2]), + {table, _} = i(Q), + [] = qlc:e(Q), + false = lookup_keys(Q) + end, [{1,1},{2,0}])">>, + {warnings,[{{4,37},qlc,nomatch_filter}]}}, + + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,C} || + {A} <- ets:table(E), + A =:= 1, + {B} <- ets:table(E), + B =:= 2, + {C} <- ets:table(E), + C =:= 3]), + {qlc,_,[{generate,_,{list,{table,_},_}}, + {generate,_,{list,{table,_},_}}, + {generate,_,{list,{table,_},_}}],[]} = i(Q), + [{1,2,3}] = qlc:e(Q), + [1,2,3] = lookup_keys(Q) + end, [{0},{1},{2},{3},{4}])">> + + ], + ?line run(Config, TsS), + + Ts = [ + <<"etsc(fun(E) -> + H = qlc:q([X || {X,_} <- ets:table(E), + X =:= 2]), + {list,{table,_},_} = i(H), + [2] = qlc:e(H) + end, [{1,a},{2,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || {X,_} <- ets:table(E), + ((X =:= 2) or (X =:= 1)) and (X > 1)]), + {list,{table,_},_} = i(H), + [2] = qlc:e(H) + end, [{1,a},{2,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || {X,Y} <- ets:table(E), + (X =:= 2) and (Y =:= b)]), + {list,{table,_},_} = i(H), + [2] = qlc:e(H) + end, [{1,a},{2,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || X <- ets:table(E), + (element(1,X) =:= 2) and (X =:= {2,b})]), + {list,{table,_},_} = i(H), + [{2,b}] = qlc:e(H) + end, [{1,a},{2,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([{X,Y,Z,W} || + {X,Y} <- ets:table(E), + {Z,W} <- ets:table(E), + (Y =:= 3) or (Y =:= 4)]), + {qlc,_,[{generate,_,{table,{ets,table,_}}}, + {generate,_,{table,{ets,table,_}}}],[]} = i(H), + [{a,3,a,3},{a,3,b,5}] = lists:sort(qlc:e(H)) + end, [{a,3},{b,5}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([{X,Y} || + {X,Y=3} <- ets:table(E), % no matchspec + %% Two columns restricted, but lookup anyway + (X =:= a)]), + {qlc,_,[{generate,_,{table,_}}],[]} = i(H), + [{a,3}] = qlc:e(H) + end, [{a,3},{b,4}])">>, + + <<"etsc(fun(E) -> + V = 3, + H = qlc:q([{X,Y} || + {X,Y} <- ets:table(E), + (Y =:= V)]), % imported variable, no lookup + {table,{ets,table,_}} = i(H), + [{a,3}] = qlc:e(H) + end, [{a,3},{b,4}])">>, + + <<"etsc(fun(E) -> + V = b, + H = qlc:q([{X,Y} || + {X,Y} <- ets:table(E), + (X =:= V)]), % imported variable, lookup + {list,{table,_},_} = i(H), + [{b,4}] = qlc:e(H) + end, [{a,3},{b,4}])">>, + + <<"H = qlc:q([{A,B} || {{A,B}} <- [{{1,a}},{{2,b}}], + A =:= 1, + B =:= a]), + {list,{list,[_,_]},_} = i(H), + [{1,a}] = qlc:e(H)">>, + + <<"etsc(fun(E) -> + H = qlc:q([{A,B} || {{A,B}} <- ets:table(E), + A =:= 1, + B =:= a]), + {list,{table,_},_} = i(H), + [{1,a}] = qlc:e(H) + end, [{{1,a}},{{2,b}}])">>, + + %% The filters are skipped, and the guards of the match specifications + %% are skipped as well. Only the transformations of the matchspecs + %% are kept. + <<"etsc(fun(E1) -> + etsc(fun(E2) -> + H = qlc:q([{X,Y,Z,W} || + {X,_}=Z <- ets:table(E1), + W={Y} <- ets:table(E2), + (X =:= 1) or (X =:= 2), + (Y =:= a) or (Y =:= b)] + ,{lookup,true} + ), + {qlc,_,[{generate,_,{list,{table,_}, + [{{'$1','_'},[],['$_']}]}}, + {generate,_,{list,{table,_}, + [{{'$1'},[],['$_']}]}}],[]} + = i(H), + [{1,a,{1,a},{a}}, + {1,b,{1,a},{b}}, + {2,a,{2,b},{a}}, + {2,b,{2,b},{b}}] = qlc:e(H) + end, [{a},{b}]) + end, [{1,a},{2,b}])">>, + + %% The same example again, but this time no match specs are run. + <<"fun(Z) -> + etsc(fun(E1) -> + etsc(fun(E2) -> + H = qlc:q([{X,Y} || + Z > 2, + X <- ets:table(E1), + Y <- ets:table(E2), + (element(1, X) =:= 1) or + (element(1, X) =:= 2), + (element(1, Y) =:= a) or + (element(1, Y) =:= b)] + ,{lookup,true} + ), + {qlc,_,[_,{generate,_,{table,_}}, + {generate,_,{table,_}}],[]} = i(H), + [{{1,a},{a}}, + {{1,a},{b}}, + {{2,b},{a}}, + {{2,b},{b}}] = qlc:e(H) + end, [{a},{b}]) + end, [{1,a},{2,b}]) + end(4)">>, + + %% Once again, this time with a join. + <<"etsc(fun(E1) -> + etsc(fun(E2) -> + H = qlc:q([{X,Y,Z,W} || + {X,V}=Z <- ets:table(E1), + W={Y} <- ets:table(E2), + (X =:= 1) or (X =:= 2), + (Y =:= a) or (Y =:= b), + Y =:= V] + ,[{lookup,true},{join,merge}] + ), + {qlc,_,[{generate,_,{qlc,_, + [{generate,_,{qlc,_,[{generate,_, + {keysort,{list,{table,_},_},2,[]}}, + _C1,_C2],[]}}, + {generate,_, + {qlc,_,[{generate, _, + {keysort,{list,{table,_},_},1,[]}}, + _C3], + []}}, + _], + [{join,merge}]}},_],[]} = i(H), + [{1,a,{1,a},{a}},{2,b,{2,b},{b}}] = + lists:sort(qlc:e(H)) + end, [{a},{b}]) + end, [{1,a},{2,b}])">>, + + %% Filters 2 and 3 are not skipped. + %% (Only one filter at a time is tried by the parse transform.) + <<"etsc(fun(E) -> + H = qlc:q([X || {{A,B}=X,Y} <- ets:table(E), % no matchspec + Y =:= 3, + A =:= 1, + B =:= a]), + + {qlc,_,[{generate,_,{table,_}},_,_,_],[]}= i(H), + [{1,a}] = qlc:e(H) + end, [{{1,a},3},{{2,b},4}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || {X=_,_} <- ets:table(E), % no matchspec + (X =:= 3) and (X > 3)]), + {qlc,_,[{generate,_,{table,_}},_],[]} = i(H), + [] = qlc:e(H) + end, [{3,a},{4,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || {X=_,_} <- ets:table(E), % no matchspec + (X =:= 3) or true]), + {qlc,_,[{generate,_,{table,{ets,table,_}}},_],[]} = i(H), + [3,4] = lists:sort(qlc:e(H)) + end, [{3,a},{4,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || {X=_,_} <- ets:table(E), % no matchspec + (X =:= 3) or false]), + {qlc,_,[{generate,_,{table,_}}],[]} = i(H), + [3] = lists:sort(qlc:e(H)) + end, [{3,a},{4,b}])">>, + + <<"etsc(fun(E) -> + H = qlc:q([X || {X=_,_} <- ets:table(E), % no matchspec + (X =:= X) and (X =:= 3)]), + {qlc,_,[{generate,_,{table,_}}],[]} = i(H), + [3] = lists:sort(qlc:e(H)) + end, [{3,a},{4,b}])">>, + + %% The order of filters matters. A guard filter cannot be used + %% unless there are no non-guard filter placed before the guard + %% filter that uses the guard filter's generator. There is + %% more examples in join_filter(). + <<"etsc(fun(E) -> + %% Lookup. + Q = qlc:q([{A,B,A} || + {A=_,B} <- ets:table(E), % no match spec + A =:= 1, + begin 1/B > 0 end]), + [{1,1,1}] = lists:sort(qlc:e(Q)) + end, [{1,1},{2,0}])">>, + <<"etsc(fun(E) -> + %% No lookup. + Q = qlc:q([{A,B,A} || + {A=_,B} <- ets:table(E), % no match spec + begin 1/B > 0 end, + A =:= 1]), + {'EXIT', _} = (catch qlc:e(Q)) + end, [{1,1},{2,0}])">>, + %% The same thing, with a match specification. + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,A} || + {A,B} <- ets:table(E), % match spec + A < 2, + begin 1/B > 0 end]), + [{1,1,1}] = lists:sort(qlc:e(Q)) + end, [{1,1},{2,0}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,A} || + {A,B} <- ets:table(E), % match spec + begin 1/B > 0 end, + A < 2]), + {'EXIT', _} = (catch qlc:e(Q)) + end, [{1,1},{2,0}])">>, + %% More examples, this time two tables. + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,C,D} || + {A,B} <- ets:table(E), % match spec + A < 2, + {C,D} <- ets:table(E), + begin 1/B > 0 end, %\"invalidates\" next filter + C =:= 1, + begin 1/D > 0 end]), + {qlc,_,[{generate,_,{table,{ets,table,_}}}, + {generate,_,{table,{ets,table,_}}}, + _,_,_],[]} = i(Q), + [{1,1,1,1}] = lists:sort(qlc:e(Q)) + end, [{1,1},{2,0}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([{A,B,C,D} || + {A,B} <- ets:table(E), + {C,D} <- ets:table(E), + begin 1/B > 0 end, % \"invalidates\" two filters + A < 2, + C =:= 1, + begin 1/D > 0 end]), + {qlc,_,[{generate,_,{table,{ets,table,_}}}, + {generate,_,{table,{ets,table,_}}},_,_,_,_],[]} = i(Q), + {'EXIT', _} = (catch qlc:e(Q)) + end, [{1,1},{2,0}])">>, + <<"%% There are objects in the ETS table, but none passes the filter. + %% F() would not be run if it did not \"invalidate\" the following + %% guards. + etsc(fun(E) -> + F = fun() -> [foo || A <- [0], 1/A] end, + Q1 = qlc:q([X || {X} <- ets:table(E), + F(), % \"invalidates\" next guard + X =:= 17]), + {'EXIT', _} = (catch qlc:e(Q1)) + end, [{1},{2},{3}])">>, + <<"%% The last example works just like this one: + etsc(fun(E) -> + F = fun() -> [foo || A <- [0], 1/A] end, + Q1 = qlc:q([X || {X} <- ets:table(E), + F(), + begin X =:= 17 end]), + {'EXIT', _} = (catch qlc:e(Q1)) + end, [{1},{2},{3}])">> + + ], + ?line run(Config, Ts), + + ok. + +table_impls(suite) -> + [ets, dets]. + +ets(doc) -> + "ets:table/1,2."; +ets(suite) -> []; +ets(Config) when is_list(Config) -> + Ts = [ + <<"E = ets:new(t, [ordered_set]), + true = ets:insert(E, [{1},{2}]), + {'EXIT', _} = + (catch qlc:e(qlc:q([X || {X} <- ets:table(E, bad_option)]))), + {'EXIT', _} = + (catch qlc:e(qlc:q([X || {X} <- ets:table(E,{traverse,bad})]))), + All = [{'$1',[],['$1']}], + TravAll = {traverse,{select,All}}, + [_, _] = qlc:e(qlc:q([X || {X} <- ets:table(E, TravAll)])), + [_, _] = qlc:e(qlc:q([X || {X} <- ets:table(E,{traverse,select})])), + [1,2] = + qlc:e(qlc:q([X || {X} <- ets:table(E, {traverse, first_next})])), + [2,1] = + qlc:e(qlc:q([X || {X} <- ets:table(E, {traverse, last_prev})])), + {table,{ets,table,[_,[{traverse,{select,_}},{n_objects,1}]]}} = + i(qlc:q([X || {X} <- ets:table(E, {n_objects,1})])), + {qlc,_,[{generate,_,{table,{ets,table,[_,{n_objects,1}]}}},_],[]} = + i(qlc:q([X || {X} <- ets:table(E,{n_objects,1}), + begin (X >= 1) or (X < 1) end])), + {qlc,_,[{generate,_,{table,{ets,table,[_]}}},_],[]} = + i(qlc:q([X || {X} <- ets:table(E), + begin (X >= 1) or (X < 1) end])), + ets:delete(E)">>, + + begin + MS = ets:fun2ms(fun({X,Y}) when X > 1 -> {X,Y} end), + [<<"E = ets:new(apa,[]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + MS = ">>, io_lib:format("~w", [MS]), <<", + Q = qlc:q([X || {X,_} <- ets:table(E, {traverse, {select, MS}}), + X =:= 1]), + R = qlc:e(Q), + ets:delete(E), + [] = R">>] + end + + ], + + ?line run(Config, Ts), + ok. + +dets(doc) -> + "dets:table/1,2."; +dets(suite) -> []; +dets(Config) when is_list(Config) -> + dets:start(), + T = t, + Fname = filename(T, Config), + Ts = [ + [<<"T = t, Fname = \"">>, Fname, <<"\", + file:delete(Fname), + {ok, _} = dets:open_file(T, [{file,Fname}]), + ok = dets:insert(T, [{1},{2}]), + {'EXIT', _} = + (catch qlc:e(qlc:q([X || {X} <- dets:table(T, bad_option)]))), + {'EXIT', _} = + (catch qlc:e(qlc:q([X || {X} <- dets:table(T,{traverse,bad})]))), + {'EXIT', _} = + (catch + qlc:e(qlc:q([X || {X} <- dets:table(T,{traverse,last_prev})]))), + All = [{'$1',[],['$1']}], + TravAll = {traverse,{select,All}}, + [_,_] = qlc:e(qlc:q([X || {X} <- dets:table(T, TravAll)])), + [_,_] = qlc:e(qlc:q([X || {X} <- dets:table(T,{traverse,select})])), + [_,_] = + qlc:e(qlc:q([X || {X} <- dets:table(T, {traverse, first_next})])), + {table,{dets,table,[T,[{traverse,{select,_}},{n_objects,1}]]}} = + i(qlc:q([X || {X} <- dets:table(T, {n_objects,1})])), + {qlc,_,[{generate,_,{table,{dets,table,[t,{n_objects,1}]}}},_],[]}= + i(qlc:q([X || {X} <- dets:table(T,{n_objects,1}), + begin (X >= 1) or (X < 1) end])), + {qlc,_,[{generate,_,{table,{dets,table,[_]}}},_],[]} = + i(qlc:q([X || {X} <- dets:table(T), + begin (X >= 1) or (X < 1) end])), + H = qlc:q([X || {X} <- dets:table(T, {n_objects, default}), + begin (X =:= 1) or (X =:= 2) or (X =:= 3) end]), + [1,2] = lists:sort(qlc:e(H)), + {qlc,_,[{generate,_,{table,_}},_],[]} = i(H), + + H2 = qlc:q([X || {X} <- dets:table(T), (X =:= 1) or (X =:= 2)]), + [1,2] = lists:sort(qlc:e(H2)), + {list,{table,_},_} = i(H2), + true = binary_to_list(<< + \"ets:match_spec_run(lists:flatmap(fun(V)->dets:lookup(t,V)end,\" + \"[1,2]),ets:match_spec_compile([{{'$1'},[],['$1']}]))\">>) + == format_info(H2, true), + + H3 = qlc:q([X || {X} <- dets:table(T), (X =:= 1)]), + [1] = qlc:e(H3), + {list,{table,_},_} = i(H3), + + ok = dets:close(T), + file:delete(\"">>, Fname, <<"\"), + ok">>], + + begin + MS = ets:fun2ms(fun({X,Y}) when X > 1 -> {X,Y} end), + [<<"T = t, Fname = \"">>, Fname, <<"\", + {ok, _} = dets:open_file(T, [{file,Fname}]), + MS = ">>, io_lib:format("~w", [MS]), <<", + ok = dets:insert(T, [{1,a},{2,b},{3,c}]), + Q = qlc:q([X || {X,_} <- dets:table(T, {traverse, {select, MS}}), + X =:= 1]), + R = qlc:e(Q), + ok = dets:close(T), + file:delete(\"">>, Fname, <<"\"), + [] = R">>] + end, + + [<<"T = t, Fname = \"">>, Fname, <<"\", + {ok, _} = dets:open_file(T, [{file,Fname}]), + Objs = [{X} || X <- lists:seq(1,10)], + ok = dets:insert(T, Objs), + {ok, Where} = dets:where(T, {2}), + ok = dets:close(T), + qlc_SUITE:crash(Fname, Where), + + {ok, _} = dets:open_file(T, [{file,Fname}]), + HT = qlc:q([X || {X} <- dets:table(T, {traverse, first_next})]), + {'EXIT',{error,{{bad_object,_},_}}} = (catch qlc:e(HT)), + _ = dets:close(T), + + {ok, _} = dets:open_file(T, [{file,Fname}]), + HMS = qlc:q([X || {X} <- dets:table(T, {traverse, select})]), + {error,{{bad_object,_},_}} = qlc:e(HMS), + _ = dets:close(T), + + {ok, _} = dets:open_file(T, [{file,Fname}]), + HLU = qlc:q([X || {X} <- dets:table(T), X =:= 2]), + {error,{{bad_object,_},_}} = qlc:e(HLU), + _ = dets:close(T), + + file:delete(Fname)">>] + + ], + + ?line run(Config, Ts), + _ = file:delete(Fname), + ok. + +join(suite) -> + [join_option, join_filter, join_lookup, join_merge, + join_sort, join_complex]. + +join_option(doc) -> + "The 'join' option (any, lookup, merge, nested_loop). Also cache/unique."; +join_option(suite) -> []; +join_option(Config) when is_list(Config) -> + Ts = [ + <<"Q1 = qlc:q([X || X <- [1,2,3]],{join,merge}), + {'EXIT', {no_join_to_carry_out,_}} = (catch {foo, qlc:info(Q1)}), + {'EXIT', {no_join_to_carry_out,_}} = (catch {foo, qlc:e(Q1)}), + + Q2 = qlc:q([X || X <- [1,2,3], X > 1],{join,merge}), + {'EXIT', {no_join_to_carry_out,_}} = (catch {foo, qlc:info(Q2)}), + {'EXIT', {no_join_to_carry_out,_}} = (catch {foo, qlc:e(Q2)}), + + Q3 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{a},{b},{c}], + X =:= Y], + {join, merge}), + + {1,0,0,2} = join_info(Q3), + [] = qlc:e(Q3), + + Q4 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{a},{b},{c}], + X > Y], + {join, lookup}), + {'EXIT', {no_join_to_carry_out, _}} = (catch {foo, qlc:info(Q4)}), + {'EXIT', {no_join_to_carry_out, _}} = (catch {foo, qlc:e(Q4)}), + + Q5 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{3},{4},{5}], + X == Y], + {join, merge}), + [{3,3}] = qlc:e(Q5), + + Q6 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{3},{4},{5}], + X == Y], + {join, lookup}), + {'EXIT', {cannot_carry_out_join, _}} = (catch {foo, qlc:info(Q6)}), + {'EXIT', {cannot_carry_out_join, _}} = (catch {foo, qlc:e(Q6)}), + + Q7 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{3},{4},{5}], + X == Y], + {join, nested_loop}), + {0,0,1,0} = join_info(Q7), + [{3,3}] = qlc:e(Q7), + + Q8 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{3},{4},{5}], + X =:= Y], + {join, nested_loop}), + {0,0,1,0} = join_info(Q8), + [{3,3}] = qlc:e(Q8), + + %% Only guards are inspected... + Q9 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{3},{4},{5}], + begin X =:= Y end], + {join, nested_loop}), + {'EXIT', {no_join_to_carry_out, _}} = (catch {foo, qlc:info(Q9)}), + {'EXIT', {no_join_to_carry_out, _}} = (catch {foo, qlc:e(Q9)}), + + Q10 = qlc:q([{X,Y} || + {X} <- [{1},{2},{3}], + {Y} <- [{3},{4},{5}], + X < Y], + {join, nested_loop}), + {'EXIT', {no_join_to_carry_out, _}} = (catch {foo, qlc:info(Q10)}), + {'EXIT', {no_join_to_carry_out, _}} = (catch {foo, qlc:e(Q10)}), + + F = fun(J) -> qlc:q([X || X <- [1,2]], {join,J}) end, + {'EXIT', {no_join_to_carry_out, _}} = + (catch {foo, qlc:e(F(merge))}), + {'EXIT', {no_join_to_carry_out, _}} = + (catch {foo, qlc:e(F(lookup))}), + {'EXIT', {no_join_to_carry_out, _}} = + (catch {foo, qlc:e(F(nested_loop))}), + [1,2] = qlc:e(F(any)), + + %% No join of columns in the same table. + Q11 = qlc:q([{X,Y} || {a = X, X = Y} <- [{a,1},{a,a},{a,3},{a,a}]], + {join,merge}), + {'EXIT', {no_join_to_carry_out, _}} = (catch qlc:e(Q11)), + Q12 = qlc:q([{X,Y} || {X = a, X = Y} <- [{a,1},{a,a},{a,3},{a,a}]], + {join,merge}), + {'EXIT', {no_join_to_carry_out, _}} = (catch qlc:e(Q12)), + %% X and Y are \"equal\" (same constants), but must not be joined. + Q13 = qlc:q([{X,Y} || {X,_Z} <- [{a,1},{a,2},{b,1},{b,2}], + {Y} <- [{a}], + (X =:= a) and (Y =:= b) or + (X =:= b) and (Y =:= a)], + {join,merge}), + {'EXIT', {no_join_to_carry_out, _}} = (catch qlc:e(Q13)) + +">>, + + <<"Q1 = qlc:q([X || X <- [1,2,3]], {lookup,true}), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch {foo, qlc:info(Q1)}), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch {foo, qlc:e(Q1)}), + Q2 = qlc:q([{X,Y} || X <- [1,2,3], Y <- [x,y,z]], lookup), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch {foo, qlc:info(Q2)}), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch {foo, qlc:e(Q2)}), + Q3 = qlc:q([X || {X} <- [{1},{2},{3}]], {lookup,true}), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch {foo, qlc:e(Q3)}), + {'EXIT', {no_lookup_to_carry_out, _}} = (catch {foo, qlc:info(Q3)}), + + E1 = create_ets(1, 10), + Q4 = qlc:q([{X,Y} || {X,Y} <- ets:table(E1), X =:= 3], lookup), + {match_spec, _} = strip_qlc_call(Q4), + [{3,3}] = qlc:e(Q4), + Q5 = qlc:q([{X,Y} || {X,Y} <- ets:table(E1), X =:= 3], {lookup,false}), + {table, ets, _} = strip_qlc_call(Q5), + [{3,3}] = qlc:e(Q5), + Q6 = qlc:q([{X,Y} || {X,Y} <- ets:table(E1), X =:= 3], {lookup,any}), + {match_spec, _} = strip_qlc_call(Q6), + [{3,3}] = qlc:e(Q6), + ets:delete(E1)">> + + ], + ?line run(Config, Ts), + + %% The 'cache' and 'unique' options of qlc/2 affects join. + CUTs = [ + <<"L1 = [1,2], + L2 = [{1,a},{2,b}], + L3 = [{a,1},{b,2}], + Q = qlc:q([{X,Y,Z} || + Z <- L1, + {X,_} <- L2, + {_,Y} <- L3, + X =:= Y], + [cache, unique]), + {qlc,_, + [{generate,_,{list,L1}}, + {generate,_,{qlc,_,[{generate,_, + {qlc,_,[{generate,_,{keysort,{list,L2},1,[]}}],[]}}, + {generate,_,{qlc,_, + [{generate,_,{keysort,{list,L3},2,[]}}],[]}},_], + [{join,merge},{cache,ets},{unique,true}]}},_], + [{unique,true}]} = i(Q), + [{1,1,1},{2,2,1},{1,1,2},{2,2,2}] = qlc:e(Q)">>, + <<"L1 = [1,2], + L2 = [{1,a},{2,b}], + L3 = [{a,1},{b,2}], + Q = qlc:q([{X,Y,Z} || + Z <- L1, + {X,_} <- L2, + {_,Y} <- L3, + X =:= Y], + []), + Options = [{cache_all,ets}, unique_all], + {qlc,_,[{generate,_,{qlc,_,[{generate,_,{list,L1}}], + [{unique,true}]}}, + {generate,_,{qlc,_, + [{generate,_,{qlc,_,[{generate,_, + {keysort,{qlc,_,[{generate,_,{list,L2}}], + [{cache,ets},{unique,true}]}, + 1,[]}}],[]}}, + {generate,_,{qlc,_, + [{generate,_,{keysort, + {qlc,_,[{generate,_,{list,L3}}], + [{cache,ets},{unique,true}]}, + 2,[]}}],[]}},_], + [{join,merge},{cache,ets},{unique,true}]}}, + _],[{unique,true}]} = i(Q, Options), + [{1,1,1},{2,2,1},{1,1,2},{2,2,2}] = qlc:e(Q, Options)">> + ], + ?line run(Config, CUTs), + + ok. + +join_filter(doc) -> + "Various aspects of filters and join."; +join_filter(suite) -> []; +join_filter(Config) when is_list(Config) -> + Ts = [ + <<"E1 = create_ets(1, 10), + Q = qlc:q([X || {X,_} <- ets:table(E1), + begin A = X * X end, % ej true (?) + X >= A]), + {'EXIT', _} = (catch qlc:e(Q)), + ets:delete(E1)">>, + + %% The order of filters matters. See also skip_filters(). + <<"Q = qlc:q([{X,Y} || {X,Y} <- [{a,1},{b,2}], + {Z,W} <- [{a,1},{c,0}], + X =:= Z, + begin Y/W > 0 end]), + [{a,1}] = qlc:e(Q)">>, + <<"Q = qlc:q([{X,Y} || {X,Y} <- [{a,1},{b,2}], + {Z,W} <- [{a,1},{c,0}], + begin Y/W > 0 end, + X =:= Z]), + {'EXIT', _} = (catch qlc:e(Q))">>, + + <<"etsc(fun(E1) -> + etsc(fun(E2) -> + F = fun() -> [foo || A <- [0], 1/A] end, + Q1 = qlc:q([X || {X} <- ets:table(E1), + {Y} <- ets:table(E2), + F(), % invalidates next filter + X =:= Y]), + {qlc,_,[{generate,_,{table,{ets,table,_}}}, + {generate,_,{table,{ets,table,_}}},_,_], + []} = i(Q1), + {'EXIT', _} = (catch qlc:e(Q1)) + end, [{1},{2},{3}]) + end, [{a},{b},{c}])">> + + ], + ?line run(Config, Ts), + ok. + +join_lookup(doc) -> + "Lookup join."; +join_lookup(suite) -> []; +join_lookup(Config) when is_list(Config) -> + Ts = [ + <<"E1 = create_ets(1, 10), + E2 = create_ets(5, 15), + Q = qlc:q([{X,Y} || {_,Y} <- ets:table(E2), + {X,_} <- ets:table(E1), + X =:= Y], [{join,lookup}]), + {0,1,0,0} = join_info_count(Q), + R = qlc:e(Q), + ets:delete(E1), + ets:delete(E2), + [{5,5},{6,6},{7,7},{8,8},{9,9},{10,10}] = lists:sort(R)">>, + + <<"E1 = create_ets(1, 10), + E2 = create_ets(5, 15), + F = fun(J) -> qlc:q([{X,Y} || {X,_} <- ets:table(E1), + {_,Y} <- ets:table(E2), + X =:= Y], {join, J}) + end, + Q = F(lookup), + {0,1,0,0} = join_info_count(Q), + R = qlc:e(Q), + ets:delete(E1), + ets:delete(E2), + [{5,5},{6,6},{7,7},{8,8},{9,9},{10,10}] = lists:sort(R)">>, + + <<"etsc(fun(E1) -> + E2 = qlc_SUITE:table([{1,a},{a},{1,b},{b}], 2, []), + Q = qlc:q([{X,Y} || {X,Y} <- ets:table(E1), % (1) + {_,Z} <- E2, % (2) + (Z =:= Y) and (X =:= a) + or + (Z =:= Y) and (X =:= b)]), + %% Cannot look up in (1) (X is keypos). Can look up (2). + %% Lookup-join: traverse (1), look up in (2). + {0,1,0,0} = join_info_count(Q), + [{a,a},{b,a}] = qlc:e(Q) + end, [{a,a},{b,a},{c,3},{d,4}])">>, + + <<"%% The pattern {X,_} is used to filter out looked up objects. + etsc(fun(E) -> + Q = qlc:q([X || {X,_} <- ets:table(E), + Y <- [{a,b},{c,d},{1,2},{3,4}], + X =:= element(1, Y)]), + {0,1,0,0} = join_info_count(Q), + [1] = qlc:e(Q) + end, [{1,2},{3}])">>, + + <<"E = ets:new(e, [bag,{keypos,2}]), + L = lists:sort([{a,1},{b,1},{c,1},{d,1}, + {aa,2},{bb,2},{cc,2},{dd,2}]), + true = ets:insert(E, L ++ [{aaa,1,1},{bbb,2,2},{ccc,3,3}]), + Q = qlc:q([Z || {_,Y}=Z <- ets:table(E), + {X} <- [{X} || X <- lists:seq(0, 10)], + X =:= Y]), + {0,1,0,0} = join_info_count(Q), + R = qlc:e(Q), + ets:delete(E), + L = lists:sort(R)">>, + + <<"E = ets:new(e, [bag,{keypos,2}]), + L = lists:sort([{a,1},{b,1},{c,1},{d,1}, + {aa,2},{bb,2},{cc,2},{dd,2}]), + true = ets:insert(E, L ++ [{aaa,1,1},{bbb,2,2},{ccc,3,3}]), + Q = qlc:q([Z || {X} <- [{X} || X <- lists:seq(0, 10)], + {_,Y}=Z <- ets:table(E), + X =:= Y]), + {0,1,0,0} = join_info_count(Q), + R = qlc:e(Q), + ets:delete(E), + L = lists:sort(R)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{b,1},{c,3}], + {Y,YY} <- qlc_SUITE:table_lookup_error([{1,a}]), + X =:= Y], + {join,lookup}), + {error, lookup, failed} = qlc:e(Q)">>, + + <<"E = create_ets(1, 10), + Q = qlc:q([{X,Y} || + {X,_} <- ets:table(E), + {_,Y} <- qlc_SUITE:table_error([{a,1}], 1, err), + X =:= Y]), + {0,1,0,0} = join_info_count(Q), + err = qlc:e(Q), + ets:delete(E)">> + + ], + ?line run(Config, Ts), + ok. + +join_merge(doc) -> + "Merge join."; +join_merge(suite) -> []; +join_merge(Config) when is_list(Config) -> + Ts = [ + <<"Q = qlc:q([{X,Y} || {X} <- [], {Y} <- [{1}], X =:= Y], + {join,merge}), + [] = qlc:e(Q) + ">>, + + <<"Q = qlc:q([{X,Y} || {X} <- [{1}], {Y} <- [], X =:= Y], + {join,merge}), + [] = qlc:e(Q) + ">>, + + <<"Q = qlc:q([{X,Y} || {X} <- [{1},{1},{1}], + {Y} <- [{1},{1},{1}], X =:= Y], + {join,merge}), + 9 = length(qlc:e(Q)) + ">>, + + <<"%% Two merge joins possible. + Q = qlc:q([{X,Y,Z,W} || {X,Y} <- [{1,a},{1,b},{1,c}], + {Z,W} <- [{1,a},{1,b},{1,c}], + X =:= Z, + Y =:= W]), + {qlc,_,[{generate,_, + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_,{keysort,{list,_},C,[]}}],[]}}, + {generate,_, + {qlc,_,[{generate,_,{keysort,{list,_},C,[]}}],[]}}, + _], + [{join,merge}]}}, + _,_],[]} = qlc:info(Q, {format,debug}), + [{1,a,1,a},{1,b,1,b},{1,c,1,c}] = qlc:e(Q)">>, + + <<"%% As the last one, but comparison. + Q = qlc:q([{X,Y,Z,W} || {X,Y} <- [{1,a},{1,b},{1,c}], + {Z,W} <- [{1,a},{1,b},{1,c}], + X == Z, % skipped + Y =:= W]), + {qlc,_,[{generate,_, + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_,{keysort,{list,_},1,[]}}],[]}}, + {generate,_, + {qlc,_,[{generate,_,{keysort,{list,_},1,[]}}],[]}}, + _], + [{join,merge}]}}, + _],[]} = qlc:info(Q, {format,debug}), + [{1,a,1,a},{1,b,1,b},{1,c,1,c}] = qlc:e(Q)">>, + + <<"%% This is no join. + Q = qlc:q([{X,Y,Z,W} || {X,Y} <- [], {Z,W} <- [], + X =:= Y, Z =:= W]), + {0,0,0,0} = join_info_count(Q)">>, + + <<"%% Used to replace empty ETS tables with [], but that won't work. + E1 = ets:new(e1, []), + E2 = ets:new(e2, []), + Q = qlc:q([{X,Z,W} || + {X, Z} <- ets:table(E1), + {W, Y} <- ets:table(E2), + X =:= Y], + {join, lookup}), + [] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">>, + + <<"Q = qlc:q([{X,Y} || {X} <- [{3},{1},{0}], + {Y} <- [{1},{2},{3}], + X =:= Y]), + {1,0,0,2} = join_info_count(Q), + [{1,1},{3,3}] = qlc:e(Q)">>, + + <<"QH = qlc:q([{X,Y,Z,W} || {X,Y} <- [{3,c},{2,b},{1,a}], + {Z,W} <- [{2,b},{4,d},{5,e},{3,c}], + X =:= Z, + Y =:= W]), + {1,0,0,2} = join_info_count(QH), + [{2,b,2,b},{3,c,3,c}] = qlc:e(QH)">>, + + <<"%% QLC finds no join column at run time... + QH = qlc:q([1 || X <- [{1,2,3},{4,5,6}], + Y <- [{1,2},{3,4}], + X =:= Y]), + {0,0,0,0} = join_info_count(QH), + [] = qlc:e(QH)">>, + + <<"QH = qlc:q([X || X <- [{1,2,3},{4,5,6}], + Y <- [{1,2},{3,4}], + element(1, X) =:= element(2, Y)]), + {1,0,0,2} = join_info_count(QH), + [{4,5,6}] = qlc:e(QH)">>, + + <<"Q = qlc:q([{A,X,Z,W} || + A <- [a,b,c], + {X,Z} <- [{a,1},{b,4},{c,6}], + {W,Y} <- [{2,a},{3,b},{4,c}], + X =:= Y], + {cache, list}), + _ = qlc:info(Q), + [{a,a,1,2},{a,b,4,3},{a,c,6,4},{b,a,1,2},{b,b,4,3}, + {b,c,6,4},{c,a,1,2},{c,b,4,3},{c,c,6,4}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{X,Y} || + {X,Z} <- [{a,1},{b,4},{c,6}], + {W,Y} <- [{2,a},{3,b},{4,c}], + Z > W, + X =:= Y], + {join,merge}), + {qlc,_,[{generate,_,{qlc,_, + [{generate,_, + {qlc,_,[{generate,_,{keysort,_,1,[]}}],[]}}, + {generate,_, + {qlc,_,[{generate,_,{keysort,_,2,[]}}], + []}},_],[{join,merge}]}}, + _,_],[]} = i(Q), + [{b,b},{c,c}] = qlc:e(Q)">>, + + <<"E1 = create_ets(1, 10), + E2 = create_ets(5, 15), + %% A match spec.; Q does not see Q1 and Q2 as lookup-tables. + Q1 = qlc:q([X || X <- ets:table(E1)]), + Q2 = qlc:q([X || X <- ets:table(E2)]), + F = fun(J) -> qlc:q([{X,Y} || X <- Q1, + Y <- Q2, + element(1,X) =:= element(1,Y)], + [{join,J}]) + end, + {'EXIT',{cannot_carry_out_join,_}} = (catch qlc:e(F(lookup))), + Q = F(merge), + {1,0,0,2} = join_info(Q), + R = lists:sort(qlc:e(Q)), + ets:delete(E1), + ets:delete(E2), + true = [{Y,Y} || X <- lists:seq(5, 10), {} =/= (Y = {X,X})] =:= R + ">>, + + <<"E1 = create_ets(1, 10), + E2 = create_ets(5, 15), + Q = qlc:q([{X,Y} || X <- ets:table(E1), + Y <- ets:table(E2), + element(1,X) =:= element(1,Y)], + [{join,merge}]), + {1,0,0,2} = join_info(Q), + R = lists:sort(qlc:e(Q)), + ets:delete(E1), + ets:delete(E2), + true = [{Y,Y} || X <- lists:seq(5, 10), {} =/= (Y = {X,X})] =:= R + ">>, + + <<"E1 = create_ets(1, 10), + E2 = create_ets(5, 15), + Q1 = qlc:q([Y || X <- ets:table(E1), begin Y = {X}, true end]), + %% A match spec.; Q does not see Q2 as a lookup-table. + %% + %% OTP-6673: lookup join is considered but since there is no + %% filter that can do the job of Q2, lookup join is not an option.. + Q2 = qlc:q([{X} || X <- ets:table(E2)]), + F = fun(J) -> + qlc:q([{X,Y} || X <- Q1, + Y <- Q2, + element(1,X) =:= element(1,Y)], + [{join,J}]) + end, + {'EXIT',{cannot_carry_out_join,_}} = (catch qlc:e(F(lookup))), + Q = F(any), + {1,0,0,2} = join_info(Q), + R = lists:sort(qlc:e(Q)), + ets:delete(E1), + ets:delete(E2), + true = [{Y,Y} || X <- lists:seq(5, 10), {} =/= (Y = {{X,X}})] =:= R + ">>, + + <<"L1 = [{1,a},{2,a},{1,b},{2,b},{1,c},{2,c}], + L2 = [{b,Y} || Y <- lists:seq(1, 10000)], + F = fun(J) -> + Q = qlc:q([{XX,YY} || + {X,XX} <- L1, + {YY,Y} <- L2, + X == Y], + {join,J}), + qlc:q([{XX1,YY1,XX2,YY2} || + {XX1,YY1} <- Q, + {XX2,YY2} <- Q]) + end, + Qm = F(merge), + Qn = F(nested_loop), + true = lists:sort(qlc:e(Qm)) =:= lists:sort(qlc:e(Qn))">>, + + <<"L1 = [{{1,a},2},{{3,c},4}], + L2 = [{a,{1,a}},{c,{4,d}}], + Q = qlc:q([{X,Y} || {X,_} <- L1, + {_,{Y,Z}} <- L2, + X == {Y,Z} + ]), + {qlc,_,[{generate,_,{qlc,_, + [{generate,_, + {qlc,_,[{generate,_,{keysort,{list,L1},1,[]}}],[]}}, + {generate,_, + {qlc,_,[{generate,_,{keysort,{list,L2},2,[]}}],[]}}, + _], + [{join,merge}]}}],[]} = i(Q), + [{{1,a},1}] = qlc:e(Q)">>, + + <<"etsc(fun(E1) -> + etsc(fun(E2) -> + Q = qlc:q([{X,Y} || {X,Y} <- ets:table(E1), % (1) + {Z} <- ets:table(E2), % (2) + (Z =:= X) and + (Y =:= a) and + (X =:= Y) or + (Y =:= b) and + (Z =:= Y)]), + %% Cannot look up in (1) (X is keypos). Can look up (2). + %% Lookup join not possible (cannot look up in (1)). + %% Merge join is possible (after lookup in (2)). + {1,0,0,2} = join_info_count(Q), + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_, + {qlc,_,[{generate,_, + {keysort, + {table,{ets,table,_}}, + 2,[]}},_C1],[]}}, + {generate,_, + {qlc,_,[{generate,_, + {keysort,{table,_},1,[]}},_C2], + []}}, + _],[{join,merge}]}},_],[]} = i(Q), + [{a,a}] = qlc:e(Q) + end, [{a}]) + end, [{a,1},{a,a},{b,1},{b,2}])">>, + + <<"Q = qlc:q([{G1,G2} || + G1<- [{1}], + G2 <- [{1}], + element(1, G1) =:= element(1, G2)]), + {1,0,0,2} = join_info(Q), + [{{1},{1}}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{X,Y} || + X <- [{1}], + Y <- [{1}], + element(1, X) =:= element(1, Y)], + {join,merge}), + {1,0,0,2} = join_info(Q), + [{{1},{1}}] = qlc:e(Q)">>, + + <<"%% Generator after the join-filter. + Q = qlc:q([Z || + {X} <- [{1},{2},{3}], + {Y} <- [{2},{3},{4}], + X =:= Y, + Z <- [1,2]]), + {qlc,_, + [{generate,_,{qlc,_, + [{generate,_,{qlc,_, + [{generate,_,{keysort,{list,[{1},{2},{3}]},1,[]}}],[]}}, + {generate,_,{qlc,_, + [{generate,_,{keysort,{list,_},1,[]}}],[]}},_], + [{join,merge}]}}, _,{generate,_,{list,_}}],[]} = i(Q), + [1,2,1,2] = qlc:e(Q)">>, + + <<"%% X and W occur twice in the pattern of the extra join handle. + Q = qlc:q([{Z,W} || + {X,Z,X} <- [{1,2,1},{1,2,2}], + {W,Y,W} <- [{a,1,a}], + X =:= Y]), + [{2,a}] = qlc:e(Q)">> + + ], + ?line run(Config, Ts), + + %% Small examples. Returning an error term. + ETs = [ + <<"F = fun(M) -> + qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2},{bb,2},{c,3},{cc,3}], + {Y,YY} <- [{0,a},{1,a},{1,aa},{2,b},{2,bb},{2,bbb}, + {3,c},{3,cc}], + X =:= Y], + {join,M}) + end, + R = qlc:e(F(nested_loop)), + R = qlc:e(F(merge))">>, + + <<"F = fun(M) -> + qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2},{bb,2},{c,3},{cc,3}], + {Y,YY} <- [{0,a},{1,a},{1,aa},{2,b},{2,bb},{2,bbb}, + {4,d}], + X =:= Y], + {join,M}) + end, + R = qlc:e(F(nested_loop)), + R = qlc:e(F(merge))">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{b,1},{c,3}], + {Y,YY} <- [{1,a}], + X =:= Y], + {join,merge}), + [{b,a}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{b,1},{c,3}], + {Y,YY} <- qlc_SUITE:table_error([{1,a}], 1, err), + X =:= Y], + {join,merge}), + err = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{aa,1}], + {Y,YY} <- [{1,a}], + X =:= Y], + {join,merge}), + [{a,a},{aa,a}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- qlc_SUITE:table_error([{a,1},{aa,1}], + 2, err), + {Y,YY} <- [{1,a}], + X =:= Y], + {join,merge}), + err = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1}], + {Y,YY} <- [{1,a},{1,aa}], + X =:= Y], + {join,merge}), + [{a,a},{a,aa}]= qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- qlc_SUITE:table_error([{a,1}], 2, err), + {Y,YY} <- [{1,a},{1,aa}], + X =:= Y], + {join,merge}), + C = qlc:cursor(Q), + [{a,a}] = qlc:next_answers(C, 1), + qlc:delete_cursor(C), + err = qlc:e(Q)">>, + + <<"F = fun(M) -> + qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2},{bb,2},{c,3},{cc,3}], + {Y,YY} <- [{0,a},{1,a},{1,aa},{2,b}, + {2,bb},{2,bbb}], + X =:= Y], + {join,M}) + end, + %% [{a,a},{a,aa},{b,b},{b,bb},{b,bbb},{bb,b},{bb,bb},{bb,bbb}] + R = qlc:e(F(nested_loop)), + R = qlc:e(F(merge))">>, + + + <<"F = fun(M) -> + qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2},{bb,2},{c,3},{cc,3}], + {Y,YY} <- qlc_SUITE:table_error([{0,a},{1,a},{1,aa}, + {2,b},{2,bb}, + {2,bbb}], + 1, err), + X =:= Y], + {join,M}) + end, + %% [{a,a},{a,aa},{b,b},{b,bb},{b,bbb},{bb,b},{bb,bb},{bb,bbb}] + err = qlc:e(F(nested_loop)), + err = qlc:e(F(merge))">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- qlc_SUITE:table_error([], 2, err), + {Y,YY} <- [{2,b},{3,c}], + X =:= Y], + {join,merge}), + err = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{c,3}], + {Y,YY} <- [{2,b},{3,c}], + X =:= Y], + {join,merge}), + [{c,c}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{aa,1}], + {Y,YY} <- [{1,a},{1,aa}], + X =:= Y], + {join,merge}), + [{a,a},{a,aa},{aa,a},{aa,aa}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2}], + {Y,YY} <- [{1,a},{1,aa}], + X =:= Y], + {join,merge}), + [{a,a},{a,aa}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2}], + {Y,YY} <- qlc_SUITE:table_error([{1,a},{1,aa}], + 1, err), + X =:= Y], + {join,merge}), + err = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{a,1},{b,2}], + {Y,YY} <- [{1,a},{1,aa},{1,aaa},{1,aaaa}], + X =:= Y], + {join,merge}), + [{a,a},{a,aa},{a,aaa},{a,aaaa}]= qlc:e(Q)">>, + + <<"Q = qlc:q([{element(1, X), element(2, Y)} || + X <- [{a,1},{aa,1}], + Y <- [{1,a},{1,aa}], + element(2, X) =:= element(1, Y)], + {join,merge}), + [{a,a},{a,aa},{aa,a},{aa,aa}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{element(1, X), element(2, Y)} || + X <- [{a,1},{aa,1}], + Y <- qlc_SUITE:table_error([], 1, err), + element(2, X) =:= element(1, Y)], + {join,merge}), + err = qlc:e(Q)">>, + + <<"Q = qlc:q([{element(1, X), element(2, Y)} || + X <- qlc_SUITE:table_error([{a,1}], 2, err), + Y <- [{2,b}], + element(2, X) =:= element(1, Y)], + {join,merge}), + err = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- [{1,a},{'1b',b},{2,b}], + {Y,YY} <- [{a,1},{b,'1b'},{c,1}], + X == Y], + {join,merge}), + [{1,1},{'1b','1b'},{2,'1b'}] = qlc:e(Q)">>, + + <<"Q = qlc:q([{XX,YY} || + {XX,X} <- qlc_SUITE:table_error([{1,a},{'1b',b},{2,b}], + 2, err), + {Y,YY} <- [{a,1},{b,'1b'},{c,1}], + X == Y], + {join,merge}), + err = qlc:e(Q)">> + + ], + ?line run(Config, ETs), + + %% Mostly examples where temporary files are needed while merging. + FTs = [ + <<"L1 = [{Y,a} || Y <- lists:seq(1, 2)], + L2 = [{a,Y} || Y <- lists:seq(1, 10000)], + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + true = qlc:e(Qm,{max_list_size, 0}) =:= qlc:e(Qn)">>, + + <<"L1 = [{Y,a} || Y <- lists:seq(1, 2)], + L2 = [{a,Y} || Y <- lists:seq(1, 10000)], + Q = qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,merge}), + {error,_,{file_error,_,_}} = + qlc:e(Q, [{max_list_size,64*1024},{tmpdir,\"/a/b/c\"}])">>, + + <<"L1 = qlc_SUITE:table_error([{1,a},{2,a}], 2, err), + L2 = [{a,Y} || Y <- lists:seq(1, 10000)], + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + err = qlc:e(Qm, {max_list_size,64*1024}), + err = qlc:e(Qn)">>, + + <<"L1 = [{Y,a} || Y <- lists:seq(1, 2)], + L2 = qlc_SUITE:table_error([{a,Y} || Y <- lists:seq(1, 10000)], + 1, err), + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + err = qlc:e(Qm, {max_list_size,64*1024}), + err = qlc:e(Qn)">>, + + <<"L1 = [{Y,a} || Y <- lists:seq(1, 2)] ++ + [{'1b',b},{2,b}] ++ [{Y,d} || Y <- lists:seq(1, 2)], + L2 = [{a,Y} || Y <- lists:seq(1, 10000)] ++ + [{b,'1b'}] ++ [{c,1}] ++ [{d,Y} || Y <- lists:seq(1, 10000)], + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + true = lists:sort(qlc:e(Qm, {max_list_size,64*1024})) =:= + lists:sort(qlc:e(Qn))">>, + + <<"F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- [{Y,a} || Y <- lists:seq(1, 2)], + {Y,YY} <- [{a,Y} || Y <- lists:seq(1,100000)], + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + true = qlc:e(Qm, {max_list_size,64*1024}) =:= qlc:e(Qn)">>, + + %% More than one join in one QLC expression. + <<"L1 = [{Y,a} || Y <- lists:seq(1, 2)], + L2 = [{a,Y} || Y <- lists:seq(1, 10000)], + F = fun(J) -> + Q = qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y, + begin XX > 1 end, + begin YY > 9999 end], + {join,J}), + qlc:q([{XX1,YY1,XX2,YY2} || + {XX1,YY1} <- Q, + {XX2,YY2} <- Q]) + end, + Qm = F(merge), + Qn = F(nested_loop), + R1 = lists:sort(qlc:e(Qm, {max_list_size,64*1024})), + R2 = lists:sort(qlc:e(Qm, {max_list_size,1 bsl 31})), + true = R1 =:= lists:sort(qlc:e(Qn)), + true = R1 =:= R2">>, + + <<"L1 = [{Y,a} || Y <- lists:seq(1, 2)], + L2 = [{a,Y} || Y <- lists:seq(1, 10000)], + F = fun(J) -> + Q = qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y, + begin XX > 1 end, + begin YY > 9999 end], + {join,J}), + qlc:q([{XX1,YY1,XX2,YY2} || + {XX1,YY1} <- Q, + {XX2,YY2} <- Q, + throw(thrown)]) + end, + Qm = F(merge), + thrown = (catch {any_term, qlc:e(Qm, {max_list_size,64*1024})})">>, + + <<"%% Bigger than 64*1024. + T1 = {1, lists:seq(1, 20000)}, + L1 = [{a,T1},{b,T1}], + L2 = [{T1,a},{T1,b}], + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + R = [{a,a},{a,b},{b,a},{b,b}], + R = qlc:e(Qm, {max_list_size,64*1024}), + R = qlc:e(Qn)">>, + + <<"%% Bigger than 64*1024. No temporary files. + T1 = {1, lists:seq(1, 20000)}, + L1 = [{a,T1},{b,T1}], + L2 = [{T1,a},{T1,b}], + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + R = [{a,a},{a,b},{b,a},{b,b}], + R = qlc:e(Qm, {max_list_size,1 bsl 31}), + R = qlc:e(Qn)">> + + + ], + ?line run(Config, FTs), + + ok. + +join_sort(doc) -> + "Merge join optimizations (avoid unnecessary sorting)."; +join_sort(suite) -> []; +join_sort(Config) when is_list(Config) -> + Ts = [ + <<"H1_1 = qlc:keysort(1, [{1,2,3},{4,5,6}]), + H1 = qlc:q([X || X <- H1_1], unique), + H2 = qlc:keysort(2, [{1,2},{3,4}]), + H3 = qlc:q([{X,Y} || {X,_,_} <- H1, + {_,Y} <- H2, + X =:= Y]), + {1,0,0,2} = join_info(H3), + [{4,4}] = qlc:e(H3)">>, + + <<"H1_1 = qlc:keysort(1, [{1,2,3},{4,5,6}]), + H1 = qlc:q([X || X <- H1_1], unique), % keeps the order + H2 = qlc:keysort(2, [{1,2},{3,4}]), + H3 = qlc:q([{X,Y} || {X,_,_} <- H1, % no extra keysort + {Y,_} <- H2, % an extra keysort + X =:= Y]), + {1,0,0,3} = join_info(H3), + [{1,1}] = qlc:e(H3)">>, + + <<"H1_1 = qlc:keysort(1, [{1,2,3},{4,5,6}], {tmpdir,\"\"}), + H1 = qlc:q([X || X <- H1_1], unique), + H2 = qlc:keysort(2, [{1,2},{3,4}]), + H3 = qlc:q([{X,Y} || {_,X,_} <- H1, + {_,Y} <- H2, + X =:= Y]), + {1,0,0,3} = join_info(H3), + [{2,2}] = qlc:e(H3)">>, + + <<"H1_1 = qlc:keysort(1, [{1,2,3},{4,5,6}], {tmpdir,\"\"}), + H1 = qlc:q([X || X <- H1_1], unique), + H2 = qlc:keysort(2, [{1,2},{3,4}]), + H3 = qlc:q([{X,Y} || {_,X,_} <- H1, + {_,Y} <- H2, + X =:= Y]), + {1,0,0,3} = join_info(H3), + [{2,2}] = qlc:e(H3)">>, + + <<"H1 = qlc:sort([{1,a},{2,b},{3,c}]), + %% Since H1 is sorted it is also keysorted on the first column. + Q = qlc:q([{X, Y} || {X,_} <- H1, + {Y} <- [{0},{1},{2}], + X == Y]), + {1,0,0,1} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q)">>, + + <<"H1 = qlc:sort([{r,a,1},{r,b,2},{r,c,3}]), + Q = qlc:q([{X, Y} || {r,_,X} <- H1, % needs keysort(3) + {Y} <- [{0},{1},{2}], + X == Y]), + {1,0,0,2} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q)">>, + + <<"QH = qlc:q([X || X <- [{1,2,3},{4,5,6}], + Y <- qlc:sort([{1,2},{3,4}]), + element(1, X) =:= element(2, Y)]), + {1,0,0,2} = join_info_count(QH), + [{4,5,6}] = qlc:e(QH)">>, + + <<"H1_1 = qlc:keysort(1, [{1,2,3},{4,5,6},{1,2,3}]), + H1 = qlc:q([X || X <- H1_1], unique), + H2 = qlc:keysort(2, [{2,1},{3,4}]), + H3 = qlc:q([{X,Y} || {X,_,_} <- H1, + {_,Y} <- H2, + X =:= Y]), + H4 = qlc:keysort(1, [{1,2},{3,4},{4,a}]), + H5 = qlc:q([{X,Y} || {X,_} <- H4, + {_,Y} <- H3, + X =:= Y]), + {2,0,0,3} = join_info_count(H5), + [{1,1},{4,4}]= qlc:e(H5)">>, + + <<" + H1 = qlc:keysort(2, [{1,a,u},{2,b,k},{3,c,l}]), + H2 = qlc:q([{a,X,Y,a} || {1,X,u} <- H1, + {2,Y,k} <- H1]), + %% Neither H1 nor H2 need to be key-sorted + %% (the columns are constant). + H3 = qlc:q([{A,B,C,D,E,F,G,H} || + {A,B,C,D} <- H2, + {E,F,G,H} <- H2, + A =:= H], + {join,merge}), + {1,0,0,4} = join_info_count(H3), + [{a,a,b,a,a,a,b,a}] = qlc:e(H3)">>, + + <<"%% Q1 is sorted on X or Y. + Q1 = qlc:q([{X,Y} || + {X,_} <- qlc:keysort(1, [{1,a},{2,b}]), + {_,Y} <- qlc:keysort(2, [{aa,11},{bb,22}]), + X < Y]), + [{1,11},{1,22},{2,11},{2,22}] = qlc:e(Q1), + Q = qlc:q([{X,Y} || + {X,_} <- Q1, % no need to sort Q1 + {Y} <- [{0},{1},{2},{3}], + X =:= Y]), + {1,0,0,3} = join_info_count(Q), + [{1,1},{1,1},{2,2},{2,2}] = qlc:e(Q)">>, + + <<"H1 = qlc:keysort([2], [{r,1},{r,2},{r,3}]), + %% H1 is actually sorted, but this info is not captured. + Q = qlc:q([{X, Y} || {r,X} <- H1, + {Y} <- [{0},{1},{2}], + X == Y]), + {1,0,0,2} = join_info_count(Q), + [{1,1},{2,2}] = qlc:e(Q)">>, + + <<"%% Two leading constants columns and sorted objects + %% implies keysorted on column 3. + H1 = qlc:sort(qlc:q([{a,X,Y} || {X,Y} <- [{1,2},{2,3},{3,3}]])), + H2 = qlc:q([{X,Y} || + {a,3,X} <- H1, + {a,2,Y} <- H1, + X =:= Y]), + {1,0,0,0} = join_info_count(H2), + [{3,3}] = qlc:e(H2)">>, + + <<"QH = qlc:q([{X,Y} || {X,Y} <- [{1,4},{1,3}], + {Z} <- [{1}], + X =:= Z, (Y =:= 3) or (Y =:= 4)]), + {1,0,0,1} = join_info_count(QH), + [{1,4},{1,3}] = qlc:e(QH)">>, + + <<"E = ets:new(join, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E), % no need to sort + {Y} <- [{0},{1},{2}], + X == Y], {join,merge}), + {1,0,0,1} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q), + ets:delete(E)">>, + + <<"H1 = qlc:sort([{r,1,a},{r,2,b},{r,3,c}]), + Q = qlc:q([{X, Y} || {r,X,_} <- H1, % does not need keysort(3) + {Y} <- [{0},{1},{2}], + X == Y]), + {1,0,0,1} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q)">>, + + <<"H1 = qlc:keysort(2,[{r,1},{r,2},{r,3}]), + H2 = [{a},{b}], + %% Several columns in different qualifiers have initial + %% constant columns. + H3 = qlc:keysort(1,[{c1,c2,1},{foo,bar,2},{c1,c2,3},{c1,c2,2}]), + Q = qlc:q([{r,X,Y,Z} || {r,X} <- H1, + {Y} <- H2, + {c1,c2,Z} <- H3, + X =:= Z], {join,merge}), + {1,0,0,3} = join_info(Q), + [{r,1,a,1},{r,1,b,1},{r,2,a,2},{r,2,b,2},{r,3,a,3},{r,3,b,3}] = + qlc:e(Q)">>, + + <<"H1 = qlc:keysort(2,[{r,1},{r,2},{r,3}]), + H2 = [{a},{b}], + %% As the last one, but one keysort less. + H3 = qlc:keysort(3,[{c1,c2,1},{foo,bar,2},{c1,c2,3},{c1,c2,2}]), + Q = qlc:q([{r,X,Y,Z} || {r,X} <- H1, + {Y} <- H2, + {c1,c2,Z} <- H3, + X =:= Z], {join,merge}), + {1,0,0,2} = join_info(Q), + [{r,1,a,1},{r,1,b,1},{r,2,a,2},{r,2,b,2},{r,3,a,3},{r,3,b,3}] = + qlc:e(Q)">>, + + <<"H1 = qlc:keysort(2,[{r,1},{r,2},{r,3}]), + H2 = [{a},{b}], + H3 = qlc:keysort(1,[{c1,c2,1},{foo,bar,2},{c1,c2,3},{c1,c2,2}]), + %% One generator before the joined generators. + Q = qlc:q([{r,X,Y,Z} || {Y} <- H2, + {r,X} <- H1, + {c1,c2,Z} <- H3, + X =:= Z], {join,merge}), + {1,0,0,3} = join_info(Q), + [{r,1,a,1},{r,2,a,2},{r,3,a,3},{r,1,b,1},{r,2,b,2},{r,3,b,3}] = + qlc:e(Q)">>, + + <<"H1 = [{a,1},{b,2},{c,3},{d,4}], + H2 = [{a},{b}], + H3 = [{c1,c2,a},{foo,bar,b},{c1,c2,c},{c1,c2,d}], + %% A couple of \"extra\" filters and generators. + Q = qlc:q([{X,Y,Z} || {X,_} <- H1, + {Y} <- H2, + X > Y, + {c1,c2,Z} <- H3, + {W} <- [{a},{b}], + W > a, + X =:= Z]), + {1,0,0,2} = join_info(Q), + [{c,a,c},{c,b,c},{d,a,d},{d,b,d}] = qlc:e(Q)">>, + + <<"H1 = qlc:keysort(2,[{r,1},{r,2},{r,3}]), + H2 = qlc:sort([{c1,c2,1},{foo,bar,2},{c1,c2,3},{c1,c2,2}]), + %% H2 is sorted, no keysort necessary. + %% This example shows that the 'filter-part' of the pattern + %% ({c1,c2,Z}) should be evaluated _before_ the join. + %% Otherwise the objects cannot be assumed to be keysort:ed on the + %% third column (if merge join), and lookup-join would lookup + %% more keys than necessary. + Q = qlc:q([{r,X,Z} || {r,X} <- H1, + {c1,c2,Z} <- H2, + X =:= Z] ,{join,merge}), + {1,0,0,1} = join_info(Q), + [{r,1,1},{r,2,2},{r,3,3}] = qlc:e(Q)">>, + + <<"H1 = [{1,a},{2,b},{3,c}], + H2 = [{0,0},{1,1},{2,2}], + H3 = qlc:q([{A,C,D} || + {A,_B} <- H1, + {C,D} <- H2, + A == D, C == D]), + H4 = [{1,1},{2,2},{3,3}], + H5 = qlc:q([{X,Y} || + {X,_,_} <- H3, % no need to sort this one (merge join) + {_,Y} <- H4, + X == Y]), + Q = qlc:q([{X,Y} || + {X,_} <- H5, % no need to sort this one + {Y,_} <- H4, + X == Y]), + {{3,0,0,4},{3,0,0,6}} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q)">>, + + <<"%% There is an extra test (_C1, element(1, X) =:= 1) that is not + %% necessary since the match spec does the same check. This can be + %% improved upon. + Q = qlc:q([{X,Y} || + X <- [{2},{1}], + element(1, X) =:= 1, + Y=_ <- [{2},{1}], + element(1, X) =:= element(1, Y)]), + {qlc,_, + [{generate,_,{qlc,_, + [{generate,_,{qlc,_, + [{generate,_,{list,{list,_},_}}, + _C1],[]}}, + {generate,_,{qlc,_, + [{generate,_,{list,[{2},{1}]}}, + _C2],[]}},_], + [{join,merge}]}},_],[]} = i(Q), + {1,0,0,0} = join_info_count(Q), + [{{1},{1}}] = qlc:e(Q)">>, + + <<"etsc(fun(E) -> + L = [{a,b,a},{c,d,b},{1,2,a},{3,4,b}], + Q = qlc:q([P1 || {X,2,Z}=P1 <- ets:table(E), + Y <- L, + X =:= 1, + Z =:= a, + P1 =:= Y, + X =:= element(1, Y)]), + {1,0,0,0} = join_info_count(Q), + [{1,2,a}] = qlc:e(Q) + end, [{1,2,a},{3,4,b}])">>, + + %% Merge join on Z and element(3, Y). No need to sort! + <<"etsc(fun(E) -> + L = [{a,b,a},{c,d,b},{1,2,a},{3,4,b}], + Q = qlc:q([P1 || {X,2,Z}=P1 <- ets:table(E), + Y <- L, + (X =:= 1) or (X =:= 2), + Z =:= a, + P1 =:= Y, + X =:= element(1, Y)]), + {1,0,0,0} = join_info_count(Q), + [{1,2,a}] = qlc:e(Q) + end, [{1,2,a},{3,4,b}])">>, + + <<"%% Y is constant as well as X. No keysort, which means that + %% Y must be filtered before merge join. + etsc(fun(E) -> + Q = qlc:q([X || {1,2}=X <- ets:table(E), + Y <- [{a,b},{c,d},{1,2},{3,4}], + X =:= Y, + element(1, X) =:= element(1, Y)]), + {1,0,0,0} = join_info_count(Q), + [{1,2}] = qlc:e(Q) + end, [{1,2},{3,4}])">> + + ], + ?line run(Config, Ts), + ok. + +join_complex(doc) -> + "Join of more than two columns."; +join_complex(suite) -> []; +join_complex(Config) when is_list(Config) -> + Ts = [{three, + <<"three() -> + L = [], + Q = qlc:q([{X,Y,Z} || {X,_} <- L, + {_,Y} <- L, + {Z,_} <- L, + X =:= Y, Y == Z + ]), + qlc:e(Q).">>, + [], + {warnings,[{3,qlc,too_complex_join}]}}, + + {two, + <<"two() -> + Q = qlc:q([{X,Y,Z,W} || + {X} <- [], + {Y} <- [], + {Z} <- [], + {W} <- [], + X =:= Y, + Z =:= W],{join,merge}), + qlc:e(Q).">>, + [], + {warnings,[{2,qlc,too_many_joins}]}} + ], + + ?line compile(Config, Ts), + + Ts2 = [{three, + <<"three() -> + L = [], + Q = qlc:q([{X,Y,Z} || {X,_} <- L, + {_,Y} <- L, + {Z,_} <- L, + X =:= Y, Y == Z + ]), + qlc:e(Q).">>, + [], + {[], + ["cannot handle join of three or more generators efficiently"]}}, + + {two, + <<"two() -> + Q = qlc:q([{X,Y,Z,W} || + {X} <- [], + {Y} <- [], + {Z} <- [], + {W} <- [], + X =:= Y, + Z =:= W],{join,merge}), + qlc:e(Q).">>, + [], + {[],["cannot handle more than one join efficiently"]}} + ], + + ?line compile_format(Config, Ts2), + + ok. + +tickets(suite) -> + [otp_5644, otp_5195, otp_6038_bug, otp_6359, otp_6562, otp_6590, + otp_6673, otp_6964, otp_7114, otp_7232, otp_7238, otp_7552, otp_6674, + otp_7714]. + +otp_5644(doc) -> + "OTP-5644. Handle the new language element M:F/A."; +otp_5644(suite) -> []; +otp_5644(Config) when is_list(Config) -> + Ts = [ + <<"Q = qlc:q([fun modul:mfa/0 || _ <- [1,2], + is_function(fun modul:mfa/0, 0)]), + [_,_] = qlc:eval(Q)">> + ], + + ?line run(Config, Ts), + ok. + +otp_5195(doc) -> + "OTP-5195. Allow traverse functions returning terms."; +otp_5195(suite) -> []; +otp_5195(Config) when is_list(Config) -> + %% Several minor improvements have been implemented in OTP-5195. + %% The test cases are spread all over... except these. + %% + %% Traverse functions returning terms. + + Ts = [<<"L = [1,2,3], + Err = {error,modul,err}, + H = qlc:q([X || X <- qlc_SUITE:table_error(L, Err)]), + Err = qlc:e(H)">>, + + <<"Err = {error,modul,err}, + TravFun = fun() -> Err end, + H1 = qlc:sort(qlc:q([X || X <- qlc:table(TravFun, [])])), + H = qlc:q([{X} || X <- H1]), + Err = qlc:e(H)">>, + + <<"L = [1,2,3], + Err = {error,modul,err}, + H = qlc:q([X || X <- qlc_SUITE:table_error(L, Err)]), + C = qlc:cursor(H), + R = qlc:next_answers(C, all_remaining), + qlc:delete_cursor(C), + Err = R">>, + + <<"L = [1,2,3], + Err = {error,modul,err}, + H = qlc:q([X || X <- qlc_SUITE:table_error(L, Err)]), + F = fun(Obj, A) -> A++[Obj] end, + Err = qlc:fold(F, [], H)">>, + + <<"Err = {error,modul,err}, + TravFun = fun() -> Err end, + H1 = qlc:sort(qlc:q([X || X <- qlc:table(TravFun, [])])), + H = qlc:q([{X} || X <- H1]), + F = fun(Obj, A) -> A++[Obj] end, + Err = qlc:fold(F, [], H)">>, + + <<"Q1 = qlc:append([qlc:append([ugly()]),[3]]), + Q = qlc:q([X || X <- Q1]), + 42 = qlc:e(Q), + ok. + + ugly() -> + [apa | fun() -> 42 end]. + foo() -> bar">>, + + <<"L = [1,2,3], + Err = {error,modul,err}, + H = qlc:q([X || X <- qlc_SUITE:table_error(L, Err)]), + H1 = qlc:q([X || X <- H], unique), + Err = qlc:e(H1)">>, + + <<"Err = {error, module, err}, + L = [1,2,3], + H1 = qlc:q([{X} || X <- qlc_SUITE:table_error(L, Err)]), + H = qlc:q([{X,Y,Z} || X <- H1, Y <- H1, Z <- L], cache), + qlc:e(H, cache_all)">>, + + <<"Err = {error, module, err}, + L = [1,2,3], + H1 = qlc:q([X || X <- qlc_SUITE:table_error(L, Err)]), + H = qlc:q([{X,Y,Z} || X <- H1, Y <- H1, Z <- L], cache), + qlc:e(H, [cache_all,unique_all])">>, + + <<"L = [{1},{2},{3}], + H = qlc:q([X || {X} <- qlc_SUITE:table_lookup_error(L), + X =:= 2]), + {error, lookup, failed} = qlc:e(H)">>, + + %% The traverse function can return any value, but it must not + %% return an improper list. Improper lists must not be given anyway. + <<"{'EXIT', {{badfun,a},_}} = + (catch qlc:e(qlc:q([{X} || X <- [1 | a], begin true end])))">> + + ], + + ?line run(Config, Ts), + + Ts2 = [<<"Q = qlc:q([{X,Y} || {X} <- [{1},{2},{3}], + begin + %% Used to generate a badly formed file + Y = 3, true + end, + X =:= Y]), + [{3,3}] = qlc:e(Q)">>], + ?line run(Config, Ts2), + + ok. + +otp_6038_bug(doc) -> + "OTP-6038. Bug fixes: unique and keysort; cache."; +otp_6038_bug(suite) -> []; +otp_6038_bug(Config) when is_list(Config) -> + %% The 'unique' option can no longer be merged with the keysort options. + %% This used to return [{1,a},{1,c},{2,b},{2,d}], but since + %% file_sorter:keysort now removes duplicates based on keys, the + %% correct return value is [{1,a},{2,b}]. + Ts = [<<"H1 = qlc:q([X || X <- [{1,a},{2,b},{1,c},{2,d}]], unique), + H2 = qlc:keysort(1, H1, [{unique,true}]), + [{1,a},{2,b}] = qlc:e(H2)">>], + + ?line run(Config, Ts), + + %% Sometimes the cache options did not empty the correct tables. + CTs = [ + <<"Options = [cache,unique], + V1 = qlc:q([{X,Y} || X <- [1,2], Y <- [3]], Options), + V2 = qlc:q([{X,Y} || X <- [a,b], Y <- V1]), + V3 = qlc:q([{X,Y} || X <- [5,6], Y <- [7]], Options), + Q = qlc:q([{X,Y} || X <- V2, Y <- V3]), + R = qlc:e(Q), + L1 = [{X,Y} || X <- [1,2], Y <- [3]], + L2 = [{X,Y} || X <- [a,b], Y <- L1], + L3 = [{X,Y} || X <- [5,6], Y <- [7]], + L = [{X,Y} || X <- L2, Y <- L3], + true = R =:= L">>, + <<"Options = [cache,unique], + V1 = qlc:q([{X,Y} || X <- [1,2], Y <- [3]], Options), + V2 = qlc:q([{X,Y} || X <- [a,b], Y <- V1]), + V3 = qlc:q([{X,Y} || X <- [5,6], Y <- [7]], Options), + V4 = qlc:q([{X,Y} || X <- V2, Y <- V3], Options), + Q = qlc:q([{X,Y} || X <- [1,2], Y <- V4]), + R = qlc:e(Q), + L1 = [{X,Y} || X <- [1,2], Y <- [3]], + L2 = [{X,Y} || X <- [a,b], Y <- L1], + L3 = [{X,Y} || X <- [5,6], Y <- [7]], + L4 = [{X,Y} || X <- L2, Y <- L3], + L = [{X,Y} || X <- [1,2], Y <- L4], + true = R =:= L">> + ], + ?line run(Config, CTs), + + ok. + +otp_6359(doc) -> + "OTP-6359. dets:select() never returns the empty list."; +otp_6359(suite) -> []; +otp_6359(Config) when is_list(Config) -> + dets:start(), + T = luna, + Fname = filename(T, Config), + + Ts = [ + [<<"T = luna, Fname = \"">>, Fname, <<"\", + {ok, _} = dets:open_file(T, [{file,Fname}]), + Q = qlc:q([F || + F <- dets:table(T), + (F band ((1 bsl 0)) =/= 0), + true]), + [] = qlc:eval(Q), + ok = dets:close(T), + file:delete(\"">>, Fname, <<"\"), + ok">>] + ], + + ?line run(Config, Ts), + ok. + +otp_6562(doc) -> + "OTP-6562. compressed = false (should be []) when sorting before join."; +otp_6562(suite) -> []; +otp_6562(Config) when is_list(Config) -> + Bug = [ + %% This example uses a file to sort E2 on the second column. It is + %% not easy to verify that this happens; the file_sorter module's + %% size option cannot be set in this case. But it is not likely + %% that the default size (512 KiB) will ever change, so it should + %% be future safe. + <<"E1 = create_ets(1, 10), + E2 = create_ets(5, 150000), + Q = qlc:q([{XX,YY} || + {X,XX} <- ets:table(E1), + {YY,Y} <- ets:table(E2), + X == Y], + {join,merge}), + [{5,5},{6,6},{7,7},{8,8},{9,9},{10,10}] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">> + ], + ?line run(Config, Bug), + + Bits = [ + {otp_6562_1, + <<"otp_6562_1() -> + Q = qlc:q([X || <<X:8>> <= <<\"hej\">>]), + qlc:info(Q). + ">>, + [], + {errors,[{2,qlc,binary_generator}], + []}} + ], + ?line [] = compile(Config, Bits), + + ?line R1 = {error,qlc,{1,qlc,binary_generator}} + = qlc:string_to_handle("[X || <<X:8>> <= <<\"hej\">>]."), + ?line "1: cannot handle binary generators\n" = + lists:flatten(qlc:format_error(R1)), + + ok. + +otp_6590(doc) -> + "OTP-6590. Bug fix (join info)."; +otp_6590(suite) -> []; +otp_6590(Config) when is_list(Config) -> + Ts = [<<"fun(Tab1Value) -> + Q = qlc:q([T1#tab1.id || T1 <- [#tab1{id = id1, + value = v, + tab2_id = id}], + T2 <- [#tab2{id = id}], + T1#tab1.value =:= Tab1Value, + T1#tab1.tab2_id =:= T2#tab2.id]), + [id1] = qlc:e(Q) + end(v)">>], + + ?line run(Config, <<"-record(tab1, {id, tab2_id, value}). + -record(tab2, {id, value}).\n">>, Ts), + ok. + +otp_6673(doc) -> + "OTP-6673. Optimizations and fixes."; +otp_6673(suite) -> []; +otp_6673(Config) when is_list(Config) -> + Ts_PT = + [<<"etsc(fun(E1) -> + etsc(fun(E2) -> + Q = qlc:q([{A,B,C,D} || + {A,B} <- ets:table(E1), + {C,D} <- ets:table(E2), + A =:= 2, % lookup + B =:= D, % join + C =:= g]), % lookup invalidated by join + {qlc,_,[{generate,_, + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_, + {keysort, + {list,{table,_}, + [{{'$1','$2'},[],['$_']}]}, + 2,[]}},_],[]}}, + {generate,_,{qlc,_, + [{generate,_, + {keysort,{table,_},2,[]}}], + []}},_], + [{join,merge}]}},_,_],[]} = i(Q), + [{2,y,g,y}] = qlc:e(Q) + end, [{f,x},{g,y},{h,z}]) + end, + [{1,x},{2,y},{3,z}])">>, + <<"etsc(fun(E1) -> + etsc(fun(E2) -> + Q = qlc:q([{A,B,C,D} || + {A,B} <- ets:table(E1), + {C,D} <- ets:table(E2), + A =:= 2, % lookup + C =:= g, % lookup + B =:= D]), % join + {qlc,_,[{generate,_, + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_, + {keysort, + {list,{table,_}, + [{{'$1','$2'},[],['$_']}]}, + 2,[]}},_],[]}}, + {generate,_,{qlc,_, + [{generate,_, + {keysort, + {list,{table,_}, + [{{'$1','$2'},[],['$_']}]}, + 2,[]}},_],[]}},_], + [{join,merge}]}},_],[]} = i(Q), + [{2,y,g,y}] = qlc:e(Q) + end, [{f,x},{g,y},{h,z}]) + end, + [{1,x},{2,y},{3,z}])">>], + + ?line run(Config, Ts_PT), + + MS = ets:fun2ms(fun({X,_Y}=T) when X > 1 -> T end), + Ts_RT = [ + [<<"%% Explicit match-spec. ets:table() ensures there is no lookup + %% function, which means that lookup join will not be considered. + MS = ">>, io_lib:format("~w", [MS]), <<", + etsc(fun(E) -> + F = fun(J) -> + qlc:q([{X,W} || + {X,_Y} <- + ets:table(E,{traverse, + {select,MS}}), + {Z,W} <- [{1,1},{2,2},{3,3}], + X =:= Z], {join,J}) + end, + Qm = F(any), + [{2,2},{3,3}] = qlc:e(Qm), + {'EXIT',{cannot_carry_out_join,_}} = + (catch qlc:e(F(lookup))) + end, [{1,a},{2,b},{3,c}])">>], + + <<"%% The filter 'A =< y' can be evaluated by traversing E1 using a + %% match specification, but then lookup join cannot use E1 for + %% looking up keys. This example shows that the filter is kept if + %% lookup join is employed (otherwise it is optimized away since + %% the match spec is used). + etsc(fun(E1) -> + Q = qlc:q([{A,B,C,D} || + {A,B} <- ets:table(E1), + {C,D} <- [{x,f},{y,g},{z,h}], + A =< y, % kept + A =:= C], {join,lookup}), + [{x,1,x,f},{y,2,y,g}] = lists:sort(qlc:e(Q)) + end, [{x,1},{y,2},{z,3}])">> + + ], + ?line run(Config, Ts_RT), + + %% Ulf Wiger provided a patch that makes QLC work with packages: + Dir = filename:join(?privdir, "p"), + ?line ok = filelib:ensure_dir(filename:join(Dir, ".")), + File = filename:join(Dir, "p.erl"), + ?line ok = file:write_file(File, + <<"-module(p.p).\n" + "-export([q/0]).\n" + "-include_lib(\"stdlib/include/qlc.hrl\").\n" + "q() ->\n" + " .qlc:q([X || X <- [1,2]]).">>), + ?line {ok, 'p.p'} = compile:file(File, [{outdir,Dir}]), + ?line code:purge('p.p'), + ?line {module, 'p.p'} = code:load_abs(filename:rootname(File), 'p.p'), + ?line [1,2] = qlc:e(p.p:q()), + + ok. + +otp_6964(doc) -> + "OTP-6964. New option 'tmpdir_usage'."; +otp_6964(suite) -> []; +otp_6964(Config) when is_list(Config) -> + T1 = [ + <<"Q1 = qlc:q([{X} || X <- [1,2]]), + {'EXIT', {badarg,_}} = (catch qlc:e(Q1, {tmpdir_usage,bad})), + %% merge join + F = fun(Use) -> + L1 = [{Y,a} || Y <- lists:seq(1, 2)], + L2 = [{a,Y} || Y <- lists:seq(1, 10000)], + Q = qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,merge}), + qlc:e(Q, [{max_list_size,64*1024},{tmpdir_usage,Use}]) + end, + D = erlang:system_flag(backtrace_depth, 0), + 20000 = length(F(allowed)), + ErrReply = F(not_allowed), + {error, qlc, {tmpdir_usage,joining}} = ErrReply, + \"temporary file was needed for joining\n\" = + lists:flatten(qlc:format_error(ErrReply)), + qlc_SUITE:install_error_logger(), + 20000 = length(F(warning_msg)), + {error, joining} = qlc_SUITE:read_error_logger(), + 20000 = length(F(info_msg)), + {info, joining} = qlc_SUITE:read_error_logger(), + 20000 = length(F(error_msg)), + {error, joining} = qlc_SUITE:read_error_logger(), + _ = erlang:system_flag(backtrace_depth, D), + qlc_SUITE:uninstall_error_logger()">>], + ?line run(Config, T1), + + T2 = [ + <<"%% File sorter. + T = lists:seq(1, 10000), + Q0 = qlc:q([{X} || X <- [T,T,T], begin X > 0 end], + [{cache,list},unique]), + Q1 = qlc:q([{X,Y,Z} || + X <- Q0, + Y <- Q0, + Z <- Q0], + [{cache,list},unique]), + Q = qlc:q([{X, Y} || Y <- [1], X <- Q1]), + F = fun(Use) -> + qlc:e(Q, [{max_list_size,10000},{tmpdir_usage,Use}]) + end, + 1 = length(F(allowed)), + ErrReply = F(not_allowed), + {error, qlc, {tmpdir_usage,caching}} = ErrReply, + \"temporary file was needed for caching\n\" = + lists:flatten(qlc:format_error(ErrReply)), + qlc_SUITE:install_error_logger(), + 1 = length(F(error_msg)), + {error, caching} = qlc_SUITE:read_error_logger(), + {error, caching} = qlc_SUITE:read_error_logger(), + 1 = length(F(warning_msg)), + {error, caching} = qlc_SUITE:read_error_logger(), + {error, caching} = qlc_SUITE:read_error_logger(), + 1 = length(F(info_msg)), + {info, caching} = qlc_SUITE:read_error_logger(), + {info, caching} = qlc_SUITE:read_error_logger(), + qlc_SUITE:uninstall_error_logger()">>], + + ?line run(Config, T2), + + T3 = [ + <<"%% sort/keysort + E1 = create_ets(1, 10), + E2 = create_ets(5, 50000), + Q = qlc:q([{XX,YY} || + {X,XX} <- ets:table(E1), + {YY,Y} <- ets:table(E2), + X == Y], + {join,merge}), + F = fun(Use) -> + qlc:e(Q, {tmpdir_usage,Use}) + end, + ErrReply = F(not_allowed), + {error,qlc,{tmpdir_usage,sorting}} = ErrReply, + \"temporary file was needed for sorting\n\" = + lists:flatten(qlc:format_error(ErrReply)), + qlc_SUITE:install_error_logger(), + L = [{5,5},{6,6},{7,7},{8,8},{9,9},{10,10}], + L = F(allowed), + L = F(error_msg), + {error, sorting} = qlc_SUITE:read_error_logger(), + L = F(info_msg), + {info, sorting} = qlc_SUITE:read_error_logger(), + L = F(warning_msg), + {error, sorting} = qlc_SUITE:read_error_logger(), + qlc_SUITE:uninstall_error_logger(), + ets:delete(E1), + ets:delete(E2)">>], + ?line run(Config, T3), + + T4 = [ + <<"%% cache list + etsc(fun(E) -> + Q0 = qlc:q([X || X <- ets:table(E), + begin element(1, X) > 5 end], + {cache,list}), + Q = qlc:q([{X, element(1,Y)} || X <- lists:seq(1, 5), + Y <- Q0]), + R = [{X,Y} || X <- lists:seq(1, 5), + Y <- lists:seq(6, 10)], + F = fun(Use) -> + qlc:e(Q, [{max_list_size, 100*1024}, + {tmpdir_usage, Use}]) + end, + R = lists:sort(F(allowed)), + qlc_SUITE:install_error_logger(), + R = lists:sort(F(info_msg)), + {info, caching} = qlc_SUITE:read_error_logger(), + R = lists:sort(F(error_msg)), + {error, caching} = qlc_SUITE:read_error_logger(), + R = lists:sort(F(warning_msg)), + {error, caching} = qlc_SUITE:read_error_logger(), + qlc_SUITE:uninstall_error_logger(), + ErrReply = F(not_allowed), + {error,qlc,{tmpdir_usage,caching}} = ErrReply, + \"temporary file was needed for caching\n\" = + lists:flatten(qlc:format_error(ErrReply)) + end, [{keypos,1}], [{I,a,lists:duplicate(100000,1)} || + I <- lists:seq(1, 10)])">>], + ?line run(Config, T4), + ok. + +otp_7238(doc) -> + "OTP-7238. info-option 'depth', &c."; +otp_7238(suite) -> []; +otp_7238(Config) when is_list(Config) -> + dets:start(), + T = otp_7238, + Fname = filename(T, Config), + + ?line ok = compile_gb_table(Config), + + %% A few more warnings. + T1 = [ + %% The same error message string, but with different tags + %% (the strings are not compared :-( + {nomatch_1, + <<"nomatch_1() -> + {qlc:q([X || X={X} <- []]), [t || \"a\"=\"b\" <- []]}.">>, + [], + {warnings,[{{2,30},qlc,nomatch_pattern}, + {{2,44},v3_core,nomatch}]}}, + + %% Not found by qlc... + {nomatch_2, + <<"nomatch_2() -> + qlc:q([t || {\"a\"++\"b\"} = {\"ac\"} <- []]).">>, + [], + {warnings,[{{2,22},v3_core,nomatch}]}}, + + {nomatch_3, + <<"nomatch_3() -> + qlc:q([t || [$a, $b] = \"ba\" <- []]).">>, + [], + {warnings,[{{2,37},qlc,nomatch_pattern}]}}, + + %% Not found by qlc... + {nomatch_4, + <<"nomatch_4() -> + qlc:q([t || \"a\"++_=\"b\" <- []]).">>, + [], + {warnings,[{{2,22},v3_core,nomatch}]}}, + + %% Found neither by the compiler nor by qlc... + {nomatch_5, + <<"nomatch_5() -> + qlc:q([X || X = <<X>> <- [3]]).">>, + [], + []}, + + {nomatch_6, + <<"nomatch_6() -> + qlc:q([X || X <- [], + X =:= {X}]).">>, + [], + {warnings,[{{3,30},qlc,nomatch_filter}]}}, + + {nomatch_7, + <<"nomatch_7() -> + qlc:q([X || {X=Y,{Y}=X} <- []]).">>, + [], + {warnings,[{{2,28},qlc,nomatch_pattern}]}}, + + {nomatch_8, + <<"nomatch_8() -> + qlc:q([X || {X={},X=[]} <- []]).">>, + [], + {warnings,[{{2,28},qlc,nomatch_pattern}]}}, + + {nomatch_9, + <<"nomatch_9() -> + qlc:q([X || X <- [], X =:= {}, X =:= []]).">>, + [], + {warnings,[{{2,49},qlc,nomatch_filter}]}}, + + {nomatch_10, + <<"nomatch_10() -> + qlc:q([X || X <- [], + ((X =:= 1) or (X =:= 2)) and (X =:= 3)]).">>, + [], + {warnings,[{{3,53},qlc,nomatch_filter}]}}, + + {nomatch_11, + <<"nomatch_11() -> + qlc:q([X || X <- [], x =:= []]).">>, + [], + {warnings,[{{2,39},qlc,nomatch_filter}]}}, + + {nomatch_12, + <<"nomatch_12() -> + qlc:q([X || X={} <- [], X =:= []]).">>, + [], + {warnings,[{{2,42},qlc,nomatch_filter}]}}, + + {nomatch_13, + <<"nomatch_13() -> + qlc:q([Z || Z <- [], + X={X} <- [], + Y={Y} <- []]).">>, + [], + {warnings,[{{3,29},qlc,nomatch_pattern}, + {{4,29},qlc,nomatch_pattern}]}}, + + {nomatch_14, + <<"nomatch_14() -> + qlc:q([X || X={X} <- [], + 1 > 0, + 1 > X]).">>, + [], + {warnings,[{{2,29},qlc,nomatch_pattern}]}}, + + {nomatch_15, + <<"nomatch_15() -> + qlc:q([{X,Y} || X={X} <- [1], + Y <- [1], + 1 > 0, + 1 > X]).">>, + [], + {warnings,[{{2,32},qlc,nomatch_pattern}]}}, + + %% Template warning. + {nomatch_template1, + <<"nomatch_template1() -> + qlc:q([{X} = {} || X <- []]).">>, + [], + {warnings,[{2,sys_core_fold,no_clause_match}]}} + ], + ?line [] = compile(Config, T1), + + %% 'depth' is a new option used by info() + T2 = [ + %% Firstly: lists + <<"L = [[a,b,c],{a,b,c},[],<<\"foobar\">>], + Q = qlc:q([{X} || X <- L]), + {call, _, + {remote,_,{atom,_,ets},{atom,_,match_spec_run}}, + [{cons,_,{atom,_,'...'}, + {cons,_,{atom,_,'...'}, + {cons,_,{nil,_},{cons,_,{atom,_,'...'},{nil,_}}}}}, + _]} = qlc:info(Q, [{format,abstract_code},{depth,0}]), + + {call,_,_, + [{cons,_,{cons,_,{atom,_,'...'},{nil,_}}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_,{nil,_}, + {cons,_, + {bin,_, + [{_,_,{_,_,$.},_,_}, + {_,_,{_,_,$.},_,_}, + {_,_,{_,_,$.},_,_}]}, + {nil,_}}}}}, + _]} = qlc:info(Q, [{format,abstract_code},{depth,1}]), + + {call,_, + _, + [{cons,_,{cons,_,{atom,_,a},{atom,_,'...'}}, + {cons,_, + {tuple,_,[{atom,_,a},{atom,_,'...'}]}, + {cons,_,{nil,_}, + {cons,_, + {bin,_, + [{_,_,{_,_,$f},_,_}, + {_,_,{_,_,$.},_,_}, + {_,_,{_,_,$.},_,_}, + {_,_,{_,_,$.},_,_}]}, + {nil,_}}}}}, + _]} = qlc:info(Q, [{format,abstract_code},{depth,2}]), + + {call,_,_, + [{cons,_, + {cons,_,{atom,_,a},{cons,_,{atom,_,b},{atom,_,'...'}}}, + {cons,_, + {tuple,_,[{atom,_,a},{atom,_,b},{atom,_,'...'}]}, + {cons,_,{nil,_}, + {cons,_, + {bin,_, + [{_,_,{_,_,$f},_,_}, + {_,_,{_,_,$o},_,_},_,_,_]}, + {nil,_}}}}}, + _]} = qlc:info(Q, [{format,abstract_code},{depth,3}]), + + {call,_,_, + [{cons,_, + {cons,_, + {atom,_,a},{cons,_,{atom,_,b},{cons,_,{atom,_,c},{nil,_}}}}, + {cons,_, + {tuple,_,[{atom,_,a},{atom,_,b},{atom,_,c}]}, + {cons,_,{nil,_}, + {cons,_, + {bin,_, + [{_,_,{_,_,$f},_,_}, + {_,_,{_,_,$o},_,_}, + {_,_,{_,_,$o},_,_}, + {_,_,{_,_,$b},_,_}, + {_,_,{_,_,$a},_,_}, + {_,_,{_,_,$r},_,_}]}, + {nil,_}}}}}, + _]} = qlc:info(Q, [{format,abstract_code},{depth,10}]), + + {call,_,_, + [{cons,_, + {cons,_, + {atom,_,a},{cons,_,{atom,_,b},{cons,_,{atom,_,c},{nil,_}}}}, + {cons,_, + {tuple,_,[{atom,_,a},{atom,_,b},{atom,_,c}]}, + {cons,_,{nil,_}, + {cons,_, + {bin,_, + [{_,_,{_,_,$f},_,_}, + {_,_,{_,_,$o},_,_}, + {_,_,{_,_,$o},_,_}, + {_,_,{_,_,$b},_,_}, + {_,_,{_,_,$a},_,_}, + {_,_,{_,_,$r},_,_}]}, + {nil,_}}}}}, + _]} = qlc:info(Q, [{format,abstract_code},{depth,infinity}])">>, + + %% Secondly: looked up keys + <<"F = fun(D) -> + etsc(fun(E) -> + Q = qlc:q([C || {N,C} <- ets:table(E), + (N =:= {2,2}) or (N =:= {3,3})]), + F = qlc:info(Q, [{format,abstract_code},{depth,D}]), + {call,_,_,[{call,_,_,[_Fun,Values]},_]} = F, + [b,c] = lists:sort(qlc:eval(Q)), + Values + end, [{{1,1},a},{{2,2},b},{{3,3},c},{{4,4},d}]) + end, + + [{cons,_,{atom,_,'...'},{cons,_,{atom,_,'...'},{nil,_}}}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_,{tuple,_,[{atom,_,'...'}]},{nil,_}}}, + {cons,_, + {tuple,_,[{integer,_,2},{atom,_,'...'}]}, + {cons,_,{tuple,_,[{integer,_,3},{atom,_,'...'}]},{nil,_}}}, + {cons,_, + {tuple,_,[{integer,_,2},{integer,_,2}]}, + {cons,_,{tuple,_,[{integer,_,3},{integer,_,3}]},{nil,_}}}, + {cons,_, + {tuple,_,[{integer,_,2},{integer,_,2}]}, + {cons,_,{tuple,_,[{integer,_,3},{integer,_,3}]},{nil,_}}}] = + lists:map(F, [0,1,2,3,infinity])">>, + [<<"T = otp_7238, Fname = \"">>, Fname, <<"\", + {ok, _} = dets:open_file(T, [{file,Fname}]), + ok = dets:insert(T, [{{1,1},a},{{2,2},b},{{3,3},c},{{4,4},d}]), + Q = qlc:q([C || {N,C} <- dets:table(T), + (N =:= {2,2}) or (N =:= {3,3})]), + F = qlc:info(Q, [{format,abstract_code},{depth,1}]), + [b,c] = lists:sort(qlc:eval(Q)), + {call,_,_, + [{call,_,_, + [_, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_,{tuple,_,[{atom,_,'...'}]},{nil,_}}}]}, + _]} = F, + ok = dets:close(T), + file:delete(\"">>, Fname, <<"\")">>], + + %% Thirdly: format_fun has been extended (in particular: gb_table) + <<"T = gb_trees:from_orddict([{{1,a},w},{{2,b},v},{{3,c},u}]), + QH = qlc:q([X || {{X,Y},_} <- gb_table:table(T), + ((X =:= 1) or (X =:= 2)), + ((Y =:= a) or (Y =:= b) or (Y =:= c))]), + {call,_,_, + [{call,_,_, + [{'fun',_, + {clauses, + [{clause,_,_,[], + [{'case',_, + {call,_,_, + [_, + {call,_,_, + [{cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_,{tuple,_,[{atom,_,'...'}]},{nil,_}}}}]}]}, + [_,_]}]}]}}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{atom,_,'...'}]}, + {cons,_,{tuple,_,[{atom,_,'...'}]},{nil,_}}}}}}}]}, + {call,_,_, + [{cons,_,{tuple,_,[{atom,_,'...'}]},{nil,_}}]}]} = + qlc:info(QH, [{format,abstract_code},{depth,1}])">>, + <<"T1 = [{1,1,a},{2,2,b},{3,3,c},{4,4,d}], + T2 = [{x,1},{y,1},{z,2}], + QH1 = T1, + T = gb_trees:from_orddict(T2), + QH2 = qlc:q([X || {_,X} <- gb_table:table(T)], cache), + Q = qlc:q([{X1,X2,X3} || {X1,X2,X3} <- QH1, + Y2 <- QH2, + X2 =:= Y2]), + {block,_, + [{match,_,_, + {call,_,_, + [{lc,_,_, + [{generate,_,_, + {call,_,_, + [{call,_,_, + [{cons,_, + {tuple,_,[{atom,_,'...'}]}, + {atom,_,'...'}}]}]}}]}, + _]}}, + {call,_,_, + [{lc,_,_, + [{generate,_,_, + {cons,_,{tuple,_,[{atom,_,'...'}]},{atom,_,'...'}}}, + _,_]}]}]} = + qlc:info(Q, [{format,abstract_code},{depth, 1}, + {n_elements,1}])">>, + <<"L = [{{key,1},a},{{key,2},b},{{key,3},c}], + T = gb_trees:from_orddict(orddict:from_list(L)), + Q = qlc:q([K || {K,_} <- gb_table:table(T), + (K =:= {key,1}) or (K =:= {key,2})]), +{call,_,_, + [{call,_,_, + [{'fun',_, + {clauses, + [{clause,_,_,[], + [{'case',_, + {call,_,_, + [_, + {call,_,_, + [{cons,_, + {tuple,_,[{tuple,_,[{atom,_,'...'}]},{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{tuple,_,[{atom,_,'...'}]},{atom,_,'...'}]}, + {cons,_, + {tuple,_,[{tuple,_,[{atom,_,'...'}]},{atom,_,'...'}]}, + {nil,_}}}}]}]}, + _}]}]}}, + {cons,_, + {tuple,_,[{atom,_,key},{atom,_,'...'}]}, + {cons,_,{tuple,_,[{atom,_,key},{atom,_,'...'}]},{nil,_}}}]}, + {call,_, + {remote,_,{atom,_,ets},{atom,_,match_spec_compile}}, + [{cons,_, + {tuple,_,[{tuple,_,[{atom,_,'...'}]},{atom,_,'...'}]}, + {nil,_}}]}]} = + qlc:info(Q, [{format,abstract_code},{depth, 2}])">> + + ], + ?line run(Config, T2), + + T3 = [ + {nomatch_6, + <<"nomatch_6() -> + qlc:q([X || X <- [], + X =:= {X}]).">>, + [], + {[],["filter evaluates to 'false'"]}}, + + {nomatch_7, + <<"nomatch_7() -> + qlc:q([X || {X=Y,{Y}=X} <- []]).">>, + [], + {[],["pattern cannot possibly match"]}}], + ?line compile_format(Config, T3), + + %% *Very* simple test - just check that it doesn't crash. + Type = [{cres, + <<"Q = qlc:q([X || {X} <- []]), + {'EXIT',{{badfun,_},_}} = (catch qlc:e(Q))">>, + [type_checker], + []}], + ?line run(Config, Type), + + ok. + +otp_7114(doc) -> + "OTP-7114. Match spec, table and duplicated objects.."; +otp_7114(suite) -> []; +otp_7114(Config) when is_list(Config) -> + Ts = [<<"T = ets:new(t, [bag]), + [ets:insert(T, {t, I, I div 2}) || I <- lists:seq(1,10)], + Q1 = qlc:q([element(3, E) || E <- ets:table(T)]), + [0,1,1,2,2,3,3,4,4,5] = lists:sort(qlc:e(Q1)), + [0,1,2,3,4,5] = qlc:e(Q1, unique_all), + [0,1,2,3,4,5] = qlc:e(qlc:sort(Q1), unique_all), + [0,1,2,3,4,5] = qlc:e(qlc:sort(qlc:e(Q1)), unique_all), + ets:delete(T), + ok">>], + ?line run(Config, Ts). + +otp_7232(doc) -> + "OTP-7232. qlc:info() bug (pids, ports, refs, funs)."; +otp_7232(suite) -> []; +otp_7232(Config) when is_list(Config) -> + Ts = [<<"L = [fun math:sqrt/1, list_to_pid(\"<0.4.1>\"), + erlang:make_ref()], + \"[fun math:sqrt/1,<0.4.1>,#Ref<\" ++ _ = qlc:info(L), + {call,_, + {remote,_,{atom,_,qlc},{atom,_,sort}}, + [{cons,_, + {'fun',_,{function,math,sqrt,_}}, + {cons,_, + {string,_,\"<0.4.1>\"}, % could use list_to_pid.. + {cons,_,{string,_,\"#Ref<\"++_},{nil,_}}}}, + {nil,_}]} = + qlc:info(qlc:sort(L),{format,abstract_code})">>, + + <<"Q1 = qlc:q([X || X <- [1000,2000]]), + Q = qlc:sort(Q1, {order, fun(A,B)-> A>B end}), + \"qlc:sort([1000,2000],[{order,fun'-function/0-fun-2-'/2}])\" = + format_info(Q, true), + AC = qlc:info(Q, {format, abstract_code}), + \"qlc:sort([1000,2000], [{order,fun '-function/0-fun-2-'/2}])\" = + binary_to_list(iolist_to_binary(erl_pp:expr(AC)))">>, + + %% OTP-7234. erl_parse:abstract() handles bit strings + <<"Q = qlc:sort([<<17:9>>]), + \"[<<8,1:1>>]\" = qlc:info(Q)">> + + ], + ?line run(Config, Ts). + +otp_7552(doc) -> + "OTP-7552. Merge join bug."; +otp_7552(suite) -> []; +otp_7552(Config) when is_list(Config) -> + %% The poor performance cannot be observed unless the + %% (redundant) join filter is skipped. + Ts = [<<"Few = lists:seq(1, 2), + Many = lists:seq(1, 10), + S = [d,e], + L1 = [{Y,a} || Y <- Few] ++ [{'1b',b},{2,b}] ++ + [{Y,X} || X <- S, Y <- Few], + L2 = [{a,Y} || Y <- Many] ++ + [{b,'1b'}] ++ [{c,1}] ++ + [{X,Y} || X <- S, Y <- Many], + F = fun(J) -> + qlc:q([{XX,YY} || + {XX,X} <- L1, + {Y,YY} <- L2, + X == Y], + {join,J}) + end, + Qm = F(merge), + Qn = F(nested_loop), + true = lists:sort(qlc:e(Qm, {max_list_size,20})) =:= + lists:sort(qlc:e(Qn))">>], + ?line run(Config, Ts). + +otp_7714(doc) -> + "OTP-7714. Merge join bug."; +otp_7714(suite) -> []; +otp_7714(Config) when is_list(Config) -> + %% The original example uses Mnesia. This one does not. + Ts = [<<"E1 = ets:new(set,[]), + true = ets:insert(E1, {a,1}), + E2 = ets:new(set,[]), + _ = [true = ets:insert(E2, {I, 1}) || + I <- lists:seq(1, 3)], + Q = qlc:q([{A,B} || + {A,I1} <- ets:table(E1), + {B,I2} <- ets:table(E2), + I1 =:= I2],{join,merge}), + [{a,1},{a,2},{a,3}] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">>], + ?line run(Config, Ts). + +otp_6674(doc) -> + "OTP-6674. match/comparison."; +otp_6674(suite) -> []; +otp_6674(Config) when is_list(Config) -> + + ?line ok = compile_gb_table(Config), + + Ts = [%% lookup join + <<"E = ets:new(join, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E), + {Y} <- [{0},{1},{2}], + X == Y]), + {0,1,0,0} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q), + ets:delete(E)">>, + + <<"E = ets:new(join, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E), + {Y} <- [{0},{1},{2}], + X =:= Y]), + {0,1,0,0} = join_info(Q), + {block,_, + [_, + {match,_,_, + {call,_,_, + [{lc,_,_, + [_,_,{op,_,'==',_,_}]}, + {cons,_, + {tuple,_,[{atom,_,join},{atom,_,lookup}]},_}]}}, + _]} = qlc:info(Q, {format, abstract_code}), + [{1,1},{2,2}] = qlc:e(Q), + ets:delete(E)">>, + + <<"E = ets:new(join, [set]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E), + {Y} <- [{0},{1},{2}], + X == Y], {join, lookup}), + {'EXIT',{cannot_carry_out_join,_}} = (catch qlc:e(Q)), + ets:delete(E)">>, + + %% Lookup join possible in both directions. + <<"E1 = ets:new(join, [ordered_set]), + E2 = ets:new(join, [set]), + true = ets:insert(E1, [{1.0,a},{2,b},{3,c}]), + true = ets:insert(E2, [{0},{1},{2}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E1), + {Y} <- ets:table(E2), + X == Y],{join,lookup}), % skipped + {qlc,_, + [{generate,_, + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_,{table,{ets,table,[_]}}}],[]}}, + {generate,_,{table,{ets,table,[_]}}}, + _], + [{join,lookup}]}}], + []} = qlc:info(Q, {format,debug}), + {0,1,0,0} = join_info(Q), + [{1.0,1},{2,2}] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">>, + <<"E1 = ets:new(join, [ordered_set]), + E2 = ets:new(join, [set]), + true = ets:insert(E1, [{1.0,a},{2,b},{3,c}]), + true = ets:insert(E2, [{0},{1},{2}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E1), + {Y} <- ets:table(E2), + X =:= Y],{join,merge}), % not skipped + {1,0,0,1} = join_info(Q), + [{2,2}] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">>, + <<"E1 = ets:new(join, [ordered_set]), + E2 = ets:new(join, [set]), + true = ets:insert(E1, [{1.0,a},{2,b},{3,c}]), + true = ets:insert(E2, [{0},{1},{2}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E1), + {Y} <- ets:table(E2), + X =:= Y],{join,lookup}), % skipped + {qlc,_, + [{generate,_, + {qlc,_, + [{generate,_, + {qlc,_, + [{generate,_,{table,{ets,table,[_]}}}], + []}}, + {generate,_,{table,{ets,table,[_]}}}, + _], + [{join,lookup}]}}], + []} = qlc:info(Q, {format,debug}), + {0,1,0,0} = join_info(Q), + [{2,2}] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">>, + <<"E1 = ets:new(join, [ordered_set]), + E2 = ets:new(join, [set]), + true = ets:insert(E1, [{1.0,a},{2,b},{3,c}]), + true = ets:insert(E2, [{0},{1},{2}]), + Q = qlc:q([{X, Y} || {X,_} <- ets:table(E1), + {Y} <- ets:table(E2), + %% Independent of term comparison: + X =:= Y, X == Y]), + {0,1,0,0} = join_info(Q), + [{2,2}] = qlc:e(Q), + ets:delete(E1), + ets:delete(E2)">>, + + <<"E = ets:new(join, [ordered_set]), + true = ets:insert(E, [{1,1},{2,2},{3,c}]), + Q = qlc:q([{X, Y} || {X,Z} <- ets:table(E), + {Y} <- [{0},{1},{2}], + X == Z, Y == Z]), % cannot skip (yet) + {qlc,_, + [{generate,_, + {qlc,_,[_,_,_],[{join,lookup}]}}, + _,_],[]} = qlc:info(Q,{format,debug}), + {0,1,0,0} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q), + ets:delete(E)">>, + + %% The following moved here from skip_filters. It was buggy! + <<"etsc(fun(E) -> + A = 3, + Q = qlc:q([X || X <- ets:table(E), + A == element(1,X)]), + {table, _} = i(Q), + case qlc:e(Q) of + [{3},{3.0}] -> ok; + [{3.0},{3}] -> ok + end, + false = lookup_keys(Q) + end, [{3},{3.0},{c}])">>, + <<"H1 = qlc:sort([{{192,192.0},1,a},{{192.0,192.0},2,b},{{192,192.0},3,c}]), + Q = qlc:q([{X, Y} || {{A,B},X,_} <- H1, % does not need keysort(3) + A == 192, B =:= 192.0, + {Y} <- [{0},{1},{2}], + X == Y]), + {block,0, + [{match,_,_, + {call,_,_, + [{lc,_,_, + [_, + %% Has to compare extra constant: + {op,_,'==', + {tuple,_,[{integer,_,192},{float,_,192.0}]}, + {call,_,{atom,_,element},[{integer,_,1},{var,_,'P0'}]}}]}]}}, + _,_, + {call,_,_, + [{lc,_,_, + [_, + %% The join filter has been skipped. + {op,_,'==',{var,_,'A'},{integer,_,192}}, + {op,_,'=:=',{var,_,'B'},{float,_,192.0}}]}]}]} + = qlc:info(Q, {format,abstract_code}), + {1,0,0,1} = join_info(Q), + [{1,1},{2,2}] = qlc:e(Q)">>, + + %% Does not handle more than one lookup value (conjunctive). + <<"T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X =:= 1 andalso X == 1.0]), + false = lookup_keys(H), + [1] = qlc:e(H)">>, + + %% EqualConstants... + <<"etsc(fun(E) -> + Q = qlc:q([{X,Y} || {X} <- ets:table(E), + {Y} <- [{{1}},{{2}},{{1.0}},{{2.0}}], + X =:= {1}, X == {1.0}, + X == Y], {join, merge}), + [{{1},{1}},{{1},{1.0}}] = lists:sort(qlc:e(Q)), + false = lookup_keys(Q) + end, [{{1}}, {{2}}])">>, + + <<"T = gb_trees:from_orddict([{foo,{1}}, {bar,{2}}]), + Q = qlc:q([{X,Y} || {_,X} <- gb_table:table(T), + {Y} <- [{{1}},{{2}},{{1.0}},{{2.0}}], + (X =:= {1}) or (X == {2}), + (X == {1.0}) or (X =:= {2.0}), + X == Y], {join, merge}), + [{{1},{1}},{{1},{1.0}}] = qlc:e(Q)">>, + + %% Compare key + <<"T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X == 1]), + [1] = lookup_keys(H), + [1] = qlc:e(H)">>, + <<"T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X == 1.0]), + [1.0] = lookup_keys(H), % this is how gb_table works... + [1.0] = qlc:e(H)">>, + <<"etsc(fun(E) -> + H = qlc:q([X || {X,_} <- ets:table(E), + X == 1.0]), + [1] = qlc:e(H), % and this is how ETS works. + [1.0] = lookup_keys(H) + end, [ordered_set], [{1,a},{2,b}])">>, + + <<"T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X =:= 2]), + [2] = lookup_keys(H), + %% Cannot (generally) remove the matching filter (the table + %% compares the key). But note that gb_table returns the given + %% term as key, so in this case the filter _could_ have been removed. + %% However, there is no callback to inform qlc about that. + {call,_,_, + [_,{call,_,_, + [{cons,_,{tuple,_, + [_,{cons,_, + {tuple,_,[{atom,_,'=:='},{atom,_,'$1'},{integer,_,2}]}, + _},_]},_}]}]} = qlc:info(H, {format,abstract_code}), + [2] = qlc:e(H)">>, + <<"T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X =:= 2.0]), + %% Just shows that the term (not the key) is returned. + [2.0] = lookup_keys(H), + [2.0] = qlc:e(H)">>, + + <<"I = 1, + T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X == I]), % imported variable + [1] = lookup_keys(H), + {call,_,_, + [_,{call,_,_, + [{cons,_, + {tuple,_, + [{tuple,_,[{atom,_,'$1'},{atom,_,'_'}]}, + {nil,_}, % the filter has been skipped + {cons,_,{atom,_,'$1'},_}]}, + _}]}]} = qlc:info(H, {format, abstract_code}), + [1] = qlc:e(H)">>, + <<"I = 2, + T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,_} <- gb_table:table(T), + X =:= I]), + [2] = lookup_keys(H), + {call,_,_, + [_,{call,_,_, + [{cons,_,{tuple,_, + [_,{cons,_, + {tuple,_, + [{atom,_,'=:='}, + {atom,_,'$1'}, + {tuple,_,[{atom,_,const},{integer,_,2}]}]}, + _},_]}, + _}]}]} = qlc:info(H, {format, abstract_code}), + [2] = qlc:e(H)">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,_} <- ets:table(E), + X =:= a]), % skipped + [a] = qlc:e(Q), + {list,{table,_},_} = i(Q), + [a] = lookup_keys(Q) + end, [ordered_set], [{a,1},{b,2},{3,c}])">>, + + %% Does not find that if for instance X =:= {1} then the filter + %% X == {1} can be removed. + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X =:= {1}, X == {1.0}]), + [{1}] = qlc:e(Q), + [{1}] = lookup_keys(Q) + end, [{{1}}, {{2}}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X =:= {1}, X == {1.0}]), + [{1}] = qlc:e(Q), + false = lookup_keys(Q) + end, [ordered_set], [{{1}}, {{2}}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X == {1.0}, X =:= {1}]), + [{1}] = qlc:e(Q), + [{1}] = lookup_keys(Q) + end, [{{1}}, {{2}}])">>, + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X == {1.0}, X =:= {1}]), + [{1}] = qlc:e(Q), + false = lookup_keys(Q) + end, [ordered_set], [{{1}}, {{2}}])">>, + + <<"E = ets:new(apa, []), + true = ets:insert(E, [{1,a},{2,b}]), + {'EXIT', {badarg, _}} = + (catch qlc_SUITE:bad_table_key_equality(E)), + ets:delete(E)">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X} <- ets:table(E), + X =:= 1, X =:= is_integer(X)]), + [] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1}, {2}])">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X=1} <- ets:table(E), + X =:= is_integer(X)]), + {call,_,_, + [{lc,_,_, + [_, + {op,_,'=:=', + {var,_,'X'}, + {call,_, + {atom,_,is_integer}, + [{var,_,'X'}]}}]}]} = + qlc:info(Q, {format, abstract_code}), + [] = qlc:e(Q), + [1] = lookup_keys(Q) + end, [{1}, {2}])">>, + + <<"T = gb_trees:from_orddict([{1,a},{2,b}]), + H = qlc:q([X || {X,Y} <- gb_table:table(T), + Y =:= a, true, X =:= 1]), + [1] = lookup_keys(H), + [1] = qlc:e(H)">>, + + <<"T = gb_trees:from_orddict([{{1.0,1},a},{{2.0,2},b}]), + H = qlc:q([X || {{1.0,B}=X,_} <- gb_table:table(T), + B == 1]), % skipped + [{1.0, 1}] = qlc:e(H), + {qlc,_,[{generate,_,{table,_}}], []} = qlc:info(H, {format,debug})">>, + <<"T = gb_trees:from_orddict([{{1.0,1},a},{{2.0,2},b}]), + H = qlc:q([X || {{1.0,B}=X,_} <- gb_table:table(T), + B == 1.0]), % skipped + [{1.0, 1.0}] = qlc:e(H), % this is how gb_table works... + {qlc,_,[{generate,_,{table,_}}], []} = qlc:info(H, {format,debug})">>, + <<"T = gb_trees:from_orddict([{{1.0,1},a},{{2.0,2},b}]), + H = qlc:q([X || {{1.0,B}=X,_} <- gb_table:table(T), + B =:= 1.0]), % not skipped + [{1.0, 1.0}] = qlc:e(H), + {qlc,_,[{generate,_,{table,_}},_], []} = qlc:info(H,{format,debug})">>, + <<"T = gb_trees:from_orddict([{{1.0,1},a},{{2.0,2},b}]), + H = qlc:q([X || {{1.0,B}=X,_} <- gb_table:table(T), + B =:= 1]), % not skipped + [{1.0, 1}] = qlc:e(H), + {qlc,_,[{generate,_,{table,_}},_], []} = qlc:info(H,{format,debug})">>, + + <<"%% The imported variables do not interfere with join. + E = ets:new(join, [ordered_set]), + {A, B} = {1,1}, + true = ets:insert(E, [{1,a},{2,b},{3,c}]), + Q = qlc:q([{X, Y} || {X,_Z} <- ets:table(E), + {Y} <- [{0},{1},{2}], + X =:= A, Y =:= B, + Y == X], % skipped + {join, merge}), + [{1,1}] = qlc:e(Q), + {qlc,_, + [{generate,_, + {qlc,_, + [{generate,_, + {qlc,_,[{generate,_,{list,{table,_},_}},_],[]}}, + {generate,_, + {qlc,_,[{generate,_,{list,_,_}},_],[]}}, + _], + [{join,merge}]}}], + []} = qlc:info(Q, {format, debug}), + ets:delete(E)">>, + + <<"% An old bug: usort() should not be used when matching values + etsc(fun(E) -> + I = 1, + H = qlc:q([X || {X,_} <- ets:table(E), + X =:= 1.0 orelse X =:= I]), + [1] = qlc:e(H), + [1.0] = lookup_keys(H) % do not look up twice + end, [set], [{1,a},{2,b}])">>, + <<"etsc(fun(E) -> + H = qlc:q([X || {X,_} <- ets:table(E), + X =:= 1.0 orelse X == 1]), + [1] = qlc:e(H), + false = lookup_keys(H) % doesn't handle this case + end, [ordered_set], [{1,a},{2,b}])">>, + + <<"etsc(fun(E) -> + I1 = 1, I2 = 1, + H = qlc:q([X || {X,_} <- ets:table(E), + X =:= I1 orelse X == I2]), + [1] = qlc:e(H), % do not look up twice + [1] = lookup_keys(H) + end, [ordered_set], [{1,a},{2,b}])">>, + + <<"etsc(fun(E) -> + I1 = 1, I2 = 1, I3 = 1, + H = qlc:q([X || {X,_} <- ets:table(E), + I1 == I2, I1 =:= I3, I3 == I2, I2 =:= I3, + X =:= I1 orelse X == I2 + ]), + [1] = qlc:e(H), + [1] = lookup_keys(H) + end, [ordered_set], [{1,a},{2,b}])">>, + + <<"E = ets:new(join, [ordered_set]), + true = ets:insert(E, [{1,a},{2,b,x},{3,c}]), + Q = qlc:q([P || P <- ets:table(E), + P =:= {1,a} orelse P =:= {2,b,x}]), + [{1,a},{2,b,x}] = qlc:e(Q), + ets:delete(E)">>, + + <<"etsc(fun(E) -> + Q = qlc:q([X || {X,Y} <- ets:table(E), + ((X =:= 3) or (Y =:= 4)) and (X == a)]), + {list,{table,_},_} = i(Q), + [] = qlc:e(Q), % a is not an answer + [a] = lookup_keys(Q) + end, [{keypos,1},ordered_set], [{a,3},{b,4}])">>, + + <<"Q = qlc:q([{X,Y} || + {X} <- [{<<3:4>>}], + {Y} <- [{<<3:4>>}], + X =:= <<1:3,1:1>>, % <<3:4>> + Y =:= <<0:2,1:1,1:1>>, % <<3:4>> + X =:= Y]), + [{<<3:4>>,<<3:4>>}] = qlc:e(Q)">> + + + ], + + ?line run(Config, Ts). + +manpage(doc) -> + "Examples from qlc(3)."; +manpage(suite) -> []; +manpage(Config) when is_list(Config) -> + + ?line ok = compile_gb_table(Config), + + Ts = [ + <<"QH = qlc:q([{X,Y} || X <- [a,b], Y <- [1,2]]), + QC = qlc:cursor(QH), + [{a,1}] = qlc:next_answers(QC, 1), + [{a,2}] = qlc:next_answers(QC, 1), + [{b,1},{b,2}] = qlc:next_answers(QC, all_remaining), + ok = qlc:delete_cursor(QC)">>, + + <<"QH = qlc:q([{X,Y} || X <- [a,b], Y <- [1,2]]), + [{a,1},{a,2},{b,1},{b,2}] = qlc:eval(QH)">>, + + <<"QH = [1,2,3,4,5,6], + 21 = qlc:fold(fun(X, Sum) -> X + Sum end, 0, QH)">>, + + <<"QH = qlc:q([{X,Y} || X <- [x,y], Y <- [a,b]]), + B = \"begin\n\" + \" V1 =\n\" + \" qlc:q([ \n\" + \" SQV ||\n\" + \" SQV <- [x,y]\n\" + \" ],\n\" + \" [{unique,true}]),\n\" + \" V2 =\n\" + \" qlc:q([ \n\" + \" SQV ||\n\" + \" SQV <- [a,b]\n\" + \" ],\n\" + \" [{unique,true}]),\n\" + \" qlc:q([ \n\" + \" {X,Y} ||\n\" + \" X <- V1,\n\" + \" Y <- V2\n\" + \" ],\n\" + \" [{unique,true}])\n\" + \"end\", + true = B =:= qlc:info(QH, unique_all)">>, + + <<"E1 = ets:new(e1, []), + E2 = ets:new(e2, []), + true = ets:insert(E1, [{1,a},{2,b}]), + true = ets:insert(E2, [{a,1},{b,2}]), + Q = qlc:q([{X,Z,W} || + {X, Z} <- ets:table(E1), + {W, Y} <- ets:table(E2), + X =:= Y]), + L = \"begin\n\" + \" V1 =\n\" + \" qlc:q([ \n\" + \" P0 ||\n\" + \" P0 = {W,Y} <- ets:table(_)\n\" + \" ]),\n\" + \" V2 =\n\" + \" qlc:q([ \n\" + \" [G1|G2] ||\n\" + \" G2 <- V1,\n\" + \" G1 <- ets:table(_),\n\" + \" element(2, G1) =:= element(1, G2)\n\" + \" ],\n\" + \" [{join,lookup}]),\n\" + \" qlc:q([ \n\" + \" {X,Z,W} ||\n\" + \" [{X,Z}|{W,Y}] <- V2\n\" + \" ])\n\" + \"end\", + Info = + re:replace(qlc:info(Q), + \"table\\\\(-*[0-9]*\", + \"table(_\", [{return,list},global]), + L = Info, + ets:delete(E1), + ets:delete(E2)">>, + + <<"Q = qlc:q([{A,X,Z,W} || + A <- [a,b,c], + {X,Z} <- [{a,1},{b,4},{c,6}], + {W,Y} <- [{2,a},{3,b},{4,c}], + X =:= Y], + {cache, list}), + L = + \"begin\n\" + \" V1 =\n\" + \" qlc:q([ \n\" + \" P0 ||\n\" + \" P0 = {X,Z} <- qlc:keysort(1, [{a,1},{b,4},{c,6}], [])\n\" + \" ]),\n\" + \" V2 =\n\" + \" qlc:q([ \n\" + \" P0 ||\n\" + \" P0 = {W,Y} <- qlc:keysort(2, [{2,a},{3,b},{4,c}], [])\n\" + \" ]),\n\" + \" V3 =\n\" + \" qlc:q([ \n\" + \" [G1|G2] ||\n\" + \" G1 <- V1,\n\" + \" G2 <- V2,\n\" + \" element(1, G1) == element(2, G2)\n\" + \" ],\n\" + \" [{join,merge},{cache,list}]),\n\" + \" qlc:q([ \n\" + \" {A,X,Z,W} ||\n\" + \" A <- [a,b,c],\n\" + \" [{X,Z}|{W,Y}] <- V3,\n\" + \" X =:= Y\n\" + \" ])\n\" + \"end\", + L = qlc:info(Q)">>, + + <<"E1 = ets:new(t, [set]), % uses =:=/2 + Q1 = qlc:q([K || + {K} <- ets:table(E1), + K == 2.71 orelse K == a]), + {list,{table,_}, [{{'$1'},[],['$1']}]} = i(Q1), + true = ets:delete(E1)">>, + + <<"F = fun(E, I) -> + qlc:q([V || {K,V} <- ets:table(E), K == I]) + end, + E2 = ets:new(t, [set]), + true = ets:insert(E2, [{{2,2},a},{{2,2.0},b},{{2.0,2},c}]), + Q2 = F(E2, {2,2}), + {table,{ets,table,[_, + [{traverse,{select,[{{'$1','$2'}, + [{'==','$1',{const,{2,2}}}], + ['$2']}]}}]]}} = i(Q2), + [a,b,c] = lists:sort(qlc:e(Q2)), + true = ets:delete(E2), + + E3 = ets:new(t, [ordered_set]), % uses ==/2 + true = ets:insert(E3, [{{2,2.0},b}]), + Q3 = F(E3,{2,2}), + {list,{table,_},[{{'$1','$2'},[],['$2']}]} = i(Q3), + [b] = qlc:e(Q3), + true = ets:delete(E3)">>, + + <<"T = gb_trees:empty(), + QH = qlc:q([X || {{X,Y},_} <- gb_table:table(T), + ((X == 1) or (X == 2)) andalso + ((Y == a) or (Y == b) or (Y == c))]), + L = \"ets:match_spec_run(lists:flatmap(fun(K) -> + case + gb_trees:lookup(K, + gb_trees:from_orddict([])) + of + {value,V} -> + [{K,V}]; + none -> + [] + end + end, + [{1,a},{1,b},{1,c},{2,a},{2,b},{2,c}]), + ets:match_spec_compile([{{{'$1','$2'},'_'},[],['$1']}]))\", + L = qlc:info(QH)">> + ], + ?line run(Config, Ts), + + L = [1,2,3], + Bs = erl_eval:add_binding('L', L, erl_eval:new_bindings()), + QH = qlc:string_to_handle("[X+1 || X <- L].", [], Bs), + [2,3,4] = qlc:eval(QH), + + %% ets(3) + MS = ets:fun2ms(fun({X,Y}) when (X > 1) or (X < 5) -> {Y} end), + ETs = [ + [<<"true = ets:insert(Tab = ets:new(t, []),[{1,a},{2,b},{3,c},{4,d}]), + MS = ">>, io_lib:format("~w", [MS]), <<", + QH1 = ets:table(Tab, [{traverse, {select, MS}}]), + + QH2 = qlc:q([{Y} || {X,Y} <- ets:table(Tab), (X > 1) or (X < 5)]), + + true = qlc:info(QH1) =:= qlc:info(QH2), + true = ets:delete(Tab)">>]], + ?line run(Config, ETs), + + %% dets(3) + DTs = [ + [<<"{ok, T} = dets:open_file(t, []), + ok = dets:insert(T, [{1,a},{2,b},{3,c},{4,d}]), + MS = ">>, io_lib:format("~w", [MS]), <<", + QH1 = dets:table(T, [{traverse, {select, MS}}]), + + QH2 = qlc:q([{Y} || {X,Y} <- dets:table(t), (X > 1) or (X < 5)]), + + true = qlc:info(QH1) =:= qlc:info(QH2), + ok = dets:close(T)">>]], + ?line run(Config, DTs), + + ok. + +compile_gb_table(Config) -> + GB_table_file = filename("gb_table.erl", Config), + ?line ok = file:write_file(GB_table_file, gb_table()), + ?line {ok, gb_table} = compile:file(GB_table_file, [{outdir,?privdir}]), + ?line code:purge(gb_table), + ?line {module, gb_table} = + code:load_abs(filename:rootname(GB_table_file)), + ok. + +gb_table() -> + <<" +-module(gb_table). + +-export([table/1]). + +table(T) -> + TF = fun() -> qlc_next(gb_trees:next(gb_trees:iterator(T))) end, + InfoFun = fun(num_of_objects) -> gb_trees:size(T); + (keypos) -> 1; + (is_sorted_key) -> true; + (is_unique_objects) -> true; + (_) -> undefined + end, + LookupFun = + fun(1, Ks) -> + lists:flatmap(fun(K) -> + case gb_trees:lookup(K, T) of + {value, V} -> [{K,V}]; + none -> [] + end + end, Ks) + end, + FormatFun = + fun({all, NElements, ElementFun}) -> + ValsS = io_lib:format(\"gb_trees:from_orddict(~w)\", + [gb_nodes(T, NElements, ElementFun)]), + io_lib:format(\"gb_table:table(~s)\", [ValsS]); + ({lookup, 1, KeyValues, _NElements, ElementFun}) -> + ValsS = io_lib:format(\"gb_trees:from_orddict(~w)\", + [gb_nodes(T, infinity, ElementFun)]), + io_lib:format(\"lists:flatmap(fun(K) -> \" + \"case gb_trees:lookup(K, ~s) of \" + \"{value, V} -> [{K,V}];none -> [] end \" + \"end, ~w)\", + [ValsS, [ElementFun(KV) || KV <- KeyValues]]) + end, + qlc:table(TF, [{info_fun, InfoFun}, {format_fun, FormatFun}, + {lookup_fun, LookupFun},{key_equality,'=='}]). + +qlc_next({X, V, S}) -> + [{X,V} | fun() -> qlc_next(gb_trees:next(S)) end]; +qlc_next(none) -> + []. + +gb_nodes(T, infinity, ElementFun) -> + gb_nodes(T, -1, ElementFun); +gb_nodes(T, NElements, ElementFun) -> + gb_iter(gb_trees:iterator(T), NElements, ElementFun). + +gb_iter(_I, 0, _EFun) -> + '...'; +gb_iter(I0, N, EFun) -> + case gb_trees:next(I0) of + {X, V, I} -> + [EFun({X,V}) | gb_iter(I, N-1, EFun)]; + none -> + [] + end. + ">>. + +compat(suite) -> + [backward, forward]. + +backward(doc) -> + "OTP-6674. Join info and extra constants."; +backward(suite) -> []; +backward(Config) when is_list(Config) -> + case try_old_join_info(Config) of + ok -> + ok; + Reply -> + Reply + end. + +-ifdef(debug). +try_old_join_info(_Config) -> + ok. +-else. +try_old_join_info(Config) -> + case ?t:is_release_available("r12b") of + true -> + %% Check join info for handlers of extra constants. Start R12B-0. + ?line {ok, R12} = start_node_rel(r12, r12b, slave), + File = filename("handle.erl", Config), + ?line file:write_file(File, + <<"-module(handle).\n" + "-export([create_handle/0, lookup_handle/0]).\n" + "-include_lib(\"stdlib/include/qlc.hrl\").\n" + "create_handle() ->\n" + " H1 = qlc:sort([{192.0,1,a},{192.0,2,b},{192.0,3,c}]),\n" + " qlc:q([{X, Y} || {B,X,_} <- H1,\n" + " B =:= 192.0,\n" + " {Y} <- [{0},{1},{2}],\n" + " X == Y]).\n", + "\n", + "lookup_handle() ->\n" + " E = qlc_SUITE:table([{1,a},{2,b},{3,c}], 1, [1]),\n" + " qlc:q([{X, Y} || {X,_} <- E,\n" + " {Y} <- [{0},{1},{2}],\n" + " X =:= Y]).\n">>), + ?line {ok, handle} = rpc:call(R12, compile, file, + [File, [{outdir,?privdir}]]), + ?line {module, handle} = rpc:call(R12, code, load_abs, + [filename:rootname(File)]), + ?line H = rpc:call(R12, handle, create_handle, []), + ?line {module, handle} = code:load_abs(filename:rootname(File)), + ?line {block,0, + [{match,_,_, + {call,_,_, + [{lc,_,_, + [_, + {op,_,'=:=', + {float,_,192.0}, + {call,_,{atom,_,element},[{integer,_,1},_]}}]}]}}, + _,_, + {call,_,_, + [{lc,_,_, + [_, + {op,_,'=:=',{var,_,'B'},{float,_,192.0}}, + {op,_,'==',{var,_,'X'},{var,_,'Y'}}]}]}]} + = qlc:info(H,{format,abstract_code}), + ?line [{1,1},{2,2}] = qlc:e(H), + ?line H2 = rpc:call(R12, handle, lookup_handle, []), + ?line {qlc,_,[{generate,_,{qlc,_,_,[{join,lookup}]}},_],[]} = + qlc:info(H2, {format,debug}), + ?line [{1,1},{2,2}] = qlc:e(H2), + stop_node(R12); + false -> + ?line {skipped, "No support for old node"} + end. +-endif. + +forward(doc) -> + ""; +forward(suite) -> []; +forward(Config) when is_list(Config) -> + Ts = [ + %% LC_fun() returns something unknown. + <<"FakeH = {qlc_handle,{qlc_lc,fun() -> {foo,bar} end, + {qlc_opt,false,false,-1,any,[],any,524288}}}, + {'EXIT', {{unsupported_qlc_handle,_},_}} = (catch qlc:e(FakeH))">>, + +%% 'f1' should be used for new stuff that does not interfer with old behavior +% %% The unused element 'f1' of #qlc_table seems to be used. +% <<"DF = fun() -> foo end, +% FakeH = {qlc_handle,{qlc_table,DF, +% true,DF,DF,DF,DF,DF, +% undefined,not_undefined,undefined,no_match_spec}}, +% {'EXIT', {{unsupported_qlc_handle,_},_}} = (catch qlc:e(FakeH))">>, + + %% #qlc_opt has changed. + <<"H = qlc:q([X || X <- []]), + {qlc_handle, {qlc_lc, Fun, _Opt}} = H, + FakeH = {qlc_handle, {qlc_lc, Fun, {new_qlc_opt, a,b,c}}}, + {'EXIT', {{unsupported_qlc_handle,_},_}} = (catch qlc:e(FakeH))">> + + ], + ?line run(Config, Ts), + ok. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +bad_table_throw(Tab) -> + Limit = 1, + Select = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + PreFun = fun(_) -> throw({throw,bad_pre_fun}) end, + PostFun = fun() -> throw({throw,bad_post_fun}) end, + InfoFun = fun(Tag) -> info(Tab, Tag) end, + qlc:table(Select, [{pre_fun,PreFun}, {post_fun, PostFun}, + {info_fun, InfoFun}]). + +bad_table_exit(Tab) -> + Limit = 1, + Select = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + PreFun = fun(_) -> erlang:error(bad_pre_fun) end, + PostFun = fun() -> erlang:error(bad_post_fun) end, + InfoFun = fun(Tag) -> info(Tab, Tag) end, + qlc:table(Select, [{pre_fun,PreFun}, {post_fun, PostFun}, + {info_fun, InfoFun}]). + +info(_Tab, is_unique_objects) -> + false; +info(Tab, Tag) -> + try ets:info(Tab, Tag) catch _:_ -> undefined end. + +create_ets(S, E) -> + create_ets(lists:seq(S, E)). + +create_ets(L) -> + E1 = ets:new(e, []), + true = ets:insert(E1, [{X,X} || X <- L]), + E1. + +etsc(F, Objs) -> + etsc(F, [{keypos,1}], Objs). + +etsc(F, Opts, Objs) -> + E = ets:new(test, Opts), + true = ets:insert(E, Objs), + V = F(E), + ets:delete(E), + V. + +join_info(H) -> + {qlc, S, Options} = strip_qlc_call(H), + %% "Hide" the call to qlc_pt from the test in run_test(). + LoadedPT = code:is_loaded(qlc_pt), + QH = qlc:string_to_handle(S, Options), + _ = [unload_pt() || false <- [LoadedPT]], % doesn't take long... + case {join_info_count(H), join_info_count(QH)} of + {N, N} -> + N; + Ns -> + Ns + end. + +strip_qlc_call(H) -> + S = qlc:info(H, {flat, false}), + {ok, Tokens, _EndLine} = erl_scan:string(S++"."), + {ok, [Expr]} = erl_parse:parse_exprs(Tokens), + case Expr of + {call,_,{remote,_,{atom,_,qlc},{atom,_,q}},[LC]} -> + {qlc, lists:flatten([erl_pp:expr(LC), "."]), []}; + {call,_,{remote,_,{atom,_,qlc},{atom,_,q}},[LC, Opts]} -> + {qlc, lists:flatten([erl_pp:expr(LC), "."]), + erl_parse:normalise(Opts)}; + {call,_,{remote,_,{atom,_,ets},{atom,_,match_spec_run}},_} -> + {match_spec, Expr}; + {call,_,{remote,_,{atom,_,M},{atom,_,table}},_} -> + {table, M, Expr}; + _ -> + [] + end. + +-record(ji, {nmerge = 0, nlookup = 0, nnested_loop = 0, nkeysort = 0}). + +%% Counts join options and (all) calls to qlc:keysort(). +join_info_count(H) -> + S = qlc:info(H, {flat, false}), + {ok, Tokens, _EndLine} = erl_scan:string(S++"."), + {ok, [Expr]} = erl_parse:parse_exprs(Tokens), + #ji{nmerge = Nmerge, nlookup = Nlookup, + nkeysort = NKeysort, nnested_loop = Nnested_loop} = + ji(Expr, #ji{}), + {Nmerge, Nlookup, Nnested_loop, NKeysort}. + +ji({call,_,{remote,_,{atom,_,qlc},{atom,_,q}},[LC,Options]}, JI) -> + NJI = case lists:keysearch(join, 1, erl_parse:normalise(Options)) of + {value, {join, merge}} -> + JI#ji{nmerge = JI#ji.nmerge + 1}; + {value, {join, lookup}} -> + JI#ji{nlookup = JI#ji.nlookup + 1}; + {value, {join, nested_loop}} -> + JI#ji{nnested_loop = JI#ji.nnested_loop + 1}; + _ -> + JI + end, + ji(LC, NJI); +ji({call,_,{remote,_,{atom,_,qlc},{atom,_,keysort}},[_KP,H,_Options]}, JI) -> + ji(H, JI#ji{nkeysort = JI#ji.nkeysort + 1}); +ji(T, JI) when is_tuple(T) -> + ji(tuple_to_list(T), JI); +ji([E | Es], JI) -> + ji(Es, ji(E, JI)); +ji(_, JI) -> + JI. + +%% Designed for ETS' and gb_table's format funs. +lookup_keys(Q) -> + case lists:flatten(lookup_keys(i(Q), [])) of + [] -> false; + L -> lists:usort(L) + end. + +lookup_keys([Q | Qs], L) -> + lookup_keys(Qs, lookup_keys(Q, L)); +lookup_keys({qlc,_,Quals,_}, L) -> + lookup_keys(Quals, L); +lookup_keys({list,Q,_}, L) -> + lookup_keys(Q, L); +lookup_keys({generate,_,Q}, L) -> + lookup_keys(Q, L); +lookup_keys({table,Chars}, L) when is_list(Chars) -> + {ok, Tokens, _} = erl_scan:string(lists:flatten(Chars++".")), + {ok, [Expr]} = erl_parse:parse_exprs(Tokens), + case Expr of + {call,_,_,[_fun,AKs]} -> + case erl_parse:normalise(AKs) of + Ks when is_list(Ks) -> + [lists:sort(Ks) | L]; + K -> % assume keys are never lists (ets only) + [K | L] + end; + _ -> % gb_table + L + end; +lookup_keys(_Q, L) -> + L. + +bad_table_format(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + FormatFun = {is, no, good}, + qlc:table(SelectFun, [{format_fun, FormatFun}]). + +bad_table_format_arity(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + FormatFun = fun() -> {?MODULE, bad_table_format_arity, [Tab]} end, + qlc:table(SelectFun, [{format_fun, FormatFun}]). + +bad_table_traverse(Tab) -> + Limit = 1, + Select = fun(MS, _) -> cb(ets:select(Tab, MS, Limit)) end, + qlc:table(Select, []). + +bad_table_post(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + qlc:table(SelectFun, [{pre_fun,undefined}, + {post_fun, fun(X) -> X end}, + {info_fun, undefined}]). + +bad_table_lookup(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + qlc:table(SelectFun, {lookup_fun, fun(X) -> X end}). + +bad_table_max_lookup(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + qlc:table(SelectFun, {max_lookup, -2}). + +bad_table_info_arity(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + InfoFun = fun() -> {?MODULE, bad_table_info_arity, [Tab]} end, + qlc:table(SelectFun, [{info_fun, InfoFun}]). + +default_table(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + qlc:table(SelectFun, [{format_fun, undefined}, + {info_fun, undefined}, + {lookup_fun, undefined}, + {parent_fun, undefined}, + {pre_fun,undefined}, + {post_fun, undefined}]). + +bad_table(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + qlc:table(SelectFun, [{info, fun() -> ok end}]). + +bad_table_info_fun_n_objects(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + LookupFun = fun(_Pos, Ks) -> + lists:flatmap(fun(K) -> ets:lookup(Tab, K) end, Ks) + end, + InfoFun = fun(num_of_objects) -> exit(finito); + (_) -> undefined + end, + qlc:table(SelectFun, [{info_fun, InfoFun}, {lookup_fun, LookupFun}]). + +bad_table_info_fun_indices(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + LookupFun = fun(_Pos, Ks) -> + lists:flatmap(fun(K) -> ets:lookup(Tab, K) end, Ks) + end, + InfoFun = fun(indices) -> throw({throw,apa}); + (_) -> undefined + end, + qlc:table(SelectFun, [{info_fun, InfoFun}, {lookup_fun, LookupFun}]). + +bad_table_info_fun_keypos(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + LookupFun = fun(_Pos, Ks) -> + lists:flatmap(fun(K) -> ets:lookup(Tab, K) end, Ks) + end, + InfoFun = fun(indices) -> erlang:error(keypos); + (_) -> undefined + end, + qlc:table(SelectFun, [{info_fun, InfoFun}, {lookup_fun, LookupFun}]). + +bad_table_key_equality(Tab) -> + Limit = 1, + SelectFun = fun(MS) -> cb(ets:select(Tab, MS, Limit)) end, + LookupFun = fun(_Pos, Ks) -> + lists:flatmap(fun(K) -> ets:lookup(Tab, K) end, Ks) + end, + qlc:table(SelectFun, [{lookup_fun, LookupFun},{key_equality,'=/='}]). + +cb('$end_of_table') -> + []; +cb({Objects,Cont}) -> + Objects ++ fun() -> cb(ets:select(Cont)) end. + +i(H) -> + i(H, []). + +i(H, Options) when is_list(Options) -> + case has_format(Options) of + true -> qlc:info(H, Options); + false -> qlc:info(H, [{format, debug} | Options]) + end; +i(H, Option) -> + i(H, [Option]). + +has_format({format,_}) -> + true; +has_format([E | Es]) -> + has_format(E) or has_format(Es); +has_format(_) -> + false. + +format_info(H, Flat) -> + L = qlc:info(H, [{flat, Flat}, {format,string}]), + re:replace(L, "\s|\n|\t|\f|\r|\v", "", [{return,list},global]). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% A list turned into a table... + +table_kill_parent(List, Indices) -> + ParentFun = fun() -> exit(self(), kill) end, + table_i(List, Indices, ParentFun). + +table_parent_throws(List, Indices) -> + ParentFun = fun() -> throw({throw,thrown}) end, + table_i(List, Indices, ParentFun). + +table_parent_exits(List, Indices) -> + ParentFun = fun() -> 1 + Indices end, + table_i(List, Indices, ParentFun). + +table_bad_parent_fun(List, Indices) -> + ParentFun = fun(X) -> X end, % parent_fun should be nullary + table_i(List, Indices, ParentFun). + +table(List, Indices) -> + ParentFun = fun() -> self() end, + table_i(List, Indices, ParentFun). + +table(List, KeyPos, Indices) -> + ParentFun = fun() -> self() end, + table(List, Indices, KeyPos, ParentFun). + +table_i(List, Indices, ParentFun) -> + table(List, Indices, undefined, ParentFun). + +table(List, Indices, KeyPos, ParentFun) -> + TraverseFun = fun() -> list_traverse(List) end, + PreFun = fun(PreArgs) -> + {value, {parent_value, Pid}} = + lists:keysearch(parent_value, 1, PreArgs), + true = is_pid(Pid) + end, + PostFun = fun() -> ok end, + InfoFun = fun(indices) -> + Indices; + (is_unique_objects) -> + undefined; + (keypos) -> + KeyPos; + (num_of_objects) -> + undefined; + (_) -> + undefined + end, + LookupFun = + fun(Column, Values) -> + lists:flatmap(fun(V) -> + case lists:keysearch(V, Column, List) of + false -> []; + {value,Val} -> [Val] + end + end, Values) + + end, + FormatFun = fun(all) -> + L = 17, + {call,L,{remote,L,{atom,1,?MODULE},{atom,L,the_list}}, + [erl_parse:abstract(List, 17)]}; + ({lookup, Column, Values}) -> + {?MODULE, list_keys, [Values, Column, List]} + end, + qlc:table(TraverseFun, [{info_fun,InfoFun}, {pre_fun, PreFun}, + {post_fun, PostFun}, {lookup_fun, LookupFun}, + {format_fun, FormatFun}, + {parent_fun, ParentFun}]). + +stop_list(List, Ets) -> + Traverse = fun() -> list_traverse(List) end, + PV = a_sample_parent_value, + ParentFun = fun() -> PV end, + Pre = fun(PreArgs) -> + {value, {parent_value, PV}} = + lists:keysearch(parent_value, 1, PreArgs), + {value, {stop_fun, Fun}} = + lists:keysearch(stop_fun, 1, PreArgs), + true = ets:insert(Ets, {stop_fun, Fun}) + end, + qlc:table(Traverse, [{pre_fun, Pre}, {parent_fun, ParentFun}]). + +list_traverse([]) -> + []; +list_traverse([E | Es]) -> + [E | fun() -> list_traverse(Es) end]. + +table_error(List, Error) -> + table_error(List, undefined, Error). + +table_error(List, KeyPos, Error) -> + TraverseFun = fun() -> list_traverse2(lists:sort(List), Error) end, + InfoFun = fun(is_sorted_key) -> true; + (keypos) -> KeyPos; + (_) -> undefined + end, + qlc:table(TraverseFun, [{info_fun,InfoFun}]). + +list_traverse2([], Err) -> + Err; +list_traverse2([E | Es], Err) -> + [E | fun() -> list_traverse2(Es, Err) end]. + +table_lookup_error(List) -> + TraverseFun = fun() -> list_traverse(List) end, + LookupFun = fun(_Column, _Values) -> {error,lookup,failed} end, + InfoFun = fun(keypos) -> 1; + (_) -> undefined + end, + qlc:table(TraverseFun, [{lookup_fun,LookupFun},{info_fun,InfoFun}]). + +prep_scratchdir(Dir) -> + put('$qlc_tmpdir', true), + _ = filelib:ensure_dir(Dir), + lists:foreach(fun(F) -> file:delete(F) + end, filelib:wildcard(filename:join(Dir, "*"))), + true. + +%% Truncate just once. +truncate_tmpfile(Dir, Where) -> + case get('$qlc_tmpdir') of + true -> + {ok, [TmpFile0 | _]} = file:list_dir(Dir), + TmpFile = filename:join(Dir, TmpFile0), + truncate(TmpFile, Where), + erase('$qlc_tmpdir'); + _ -> + true + end. + +truncate(File, Where) -> + {ok, Fd} = file:open(File, [read, write]), + {ok, _} = file:position(Fd, Where), + ok = file:truncate(Fd), + ok = file:close(Fd). + +%% Crash just once. +crash_tmpfile(Dir, Where) -> + case get('$qlc_tmpdir') of + true -> + {ok, [TmpFile0 | _]} = file:list_dir(Dir), + TmpFile = filename:join(Dir, TmpFile0), + crash(TmpFile, Where), + erase('$qlc_tmpdir'); + _ -> + true + end. + +crash(File, Where) -> + {ok, Fd} = file:open(File, [read, write]), + {ok, _} = file:position(Fd, Where), + ok = file:write(Fd, [10]), + ok = file:close(Fd). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +run(Config, Tests) -> + run(Config, [], Tests). + +run(Config, Extra, Tests) -> + lists:foreach(fun(Body) -> run_test(Config, Extra, Body) end, Tests). + +run_test(Config, Extra, {cres, Body, ExpectedCompileReturn}) -> + run_test(Config, Extra, {cres, Body, _Opts = [], ExpectedCompileReturn}); +run_test(Config, Extra, {cres, Body, Opts, ExpectedCompileReturn}) -> + {SourceFile, Mod} = compile_file_mod(Config), + P = [Extra,<<"function() -> ">>, Body, <<", ok. ">>], + CompileReturn = compile_file(Config, P, Opts), + case comp_compare(ExpectedCompileReturn, CompileReturn) of + true -> ok; + false -> expected(ExpectedCompileReturn, CompileReturn, SourceFile) + end, + AbsFile = filename:rootname(SourceFile, ".erl"), + _ = code:purge(Mod), + {module, _} = code:load_abs(AbsFile, Mod), + + Ms0 = erlang:process_info(self(),messages), + Before = {get(), pps(), ets:all(), Ms0}, + + %% Prepare the check that the qlc module does not call qlc_pt. + _ = [unload_pt() || {file, Name} <- [code:is_loaded(qlc_pt)], + Name =/= cover_compiled], + + R = case catch Mod:function() of + {'EXIT', _Reason} = Error -> + ?t:format("failed, got ~p~n", [Error]), + fail(SourceFile); + Reply -> + Reply + end, + + %% Check that the qlc module does not call qlc_pt: + case code:is_loaded(qlc_pt) of + {file, cover_compiled} -> + ok; + {file, _} -> + ?t:format("qlc_pt was loaded in runtime~n", []), + fail(SourceFile); + false -> + ok + end, + + Ms = erlang:process_info(self(),messages), + After = {get(), pps(), ets:all(), Ms}, + code:purge(Mod), + case {R, After} of + {ok, Before} -> ok; + _ -> expected({ok,Before}, {R,After}, SourceFile) + end; +run_test(Config, Extra, Body) -> + run_test(Config, Extra, {cres,Body,[]}). + +unload_pt() -> + erlang:garbage_collect(), % get rid of references to qlc_pt... + _ = code:purge(qlc_pt), + _ = code:delete(qlc_pt). + +compile_format(Config, Tests) -> + Fun = fun(Test, Opts) -> + Return = compile_file(Config, Test, Opts), + format_messages(Return) + end, + compile(Config, Tests, Fun). + +format_messages({warnings,Ws}) -> + format_messages({errors,[],Ws}); +format_messages({errors,Es,Ws}) -> + {[format_msg(E, Mod) || {_Line,Mod,E} <- Es], + [format_msg(W, Mod) || {_Line,Mod,W} <- Ws]}. + +format_msg(Msg, Mod) -> + IOlist = Mod:format_error(Msg), + binary_to_list(iolist_to_binary(IOlist)). + +compile(Config, Tests) -> + Fun = fun(Test, Opts) -> catch compile_file(Config, Test, Opts) end, + compile(Config, Tests, Fun). + +compile(Config, Tests, Fun) -> + F = fun({TestName,Test,Opts,Expected}, BadL) -> + Return = Fun(Test, Opts), + case comp_compare(Expected, Return) of + true -> + BadL; + false -> + {File, _Mod} = compile_file_mod(Config), + expected(TestName, Expected, Return, File) + end + end, + lists:foldl(F, [], Tests). + +%% Compiles a test module and returns the list of errors and warnings. + +compile_file(Config, Test0, Opts0) -> + {File, Mod} = compile_file_mod(Config), + Test = list_to_binary(["-module(", atom_to_list(Mod), "). " + "-compile(export_all). " + "-import(qlc_SUITE, [i/1,i/2,format_info/2]). " + "-import(qlc_SUITE, [etsc/2, etsc/3]). " + "-import(qlc_SUITE, [create_ets/2]). " + "-import(qlc_SUITE, [strip_qlc_call/1]). " + "-import(qlc_SUITE, [join_info/1]). " + "-import(qlc_SUITE, [join_info_count/1]). " + "-import(qlc_SUITE, [lookup_keys/1]). " + "-include_lib(\"stdlib/include/qlc.hrl\"). ", + Test0]), + Opts = [export_all,return,nowarn_unused_record,{outdir,?privdir}|Opts0], + ok = file:write_file(File, Test), + case compile:file(File, Opts) of + {ok, _M, Ws} -> warnings(File, Ws); + {error, [{File,Es}], []} -> {errors, Es, []}; + {error, [{File,Es}], [{File,Ws}]} -> {error, Es, Ws} + end. + +comp_compare(T, T) -> + true; +comp_compare(T1, T2_0) -> + T2 = wskip(T2_0), + T1 =:= T2 + %% This clause should eventually be removed. + orelse ln(T1) =:= T2 orelse T1 =:= ln(T2). + +wskip([]) -> + []; +wskip([{_,sys_core_fold,{eval_failure,badarg}}|L]) -> + wskip(L); +wskip([{{L,_C},sys_core_fold,M}|L]) -> + [{L,sys_core_fold,M}|wskip(L)]; +wskip({T,L}) -> + {T,wskip(L)}; +wskip([M|L]) -> + [M|wskip(L)]; +wskip(T) -> + T. + +%% Replaces locations like {Line,Column} with Line. +ln({warnings,L}) -> + {warnings,ln0(L)}; +ln({errors,EL,WL}) -> + {errors,ln0(EL),ln0(WL)}; +ln(L) -> + ln0(L). + +ln0(L) -> + lists:sort(ln1(L)). + +ln1([]) -> + []; +ln1([{File,Ms}|MsL]) when is_list(File) -> + [{File,ln0(Ms)}|ln1(MsL)]; +ln1([{{L,_C},Mod,Mess0}|Ms]) -> + Mess = case Mess0 of + {exported_var,V,{Where,{L1,_C1}}} -> + {exported_var,V,{Where,L1}}; + {unsafe_var,V,{Where,{L1,_C1}}} -> + {unsafe_var,V,{Where,L1}}; + %% There are more... + M -> + M + end, + [{L,Mod,Mess}|ln1(Ms)]; +ln1([M|Ms]) -> + [M|ln1(Ms)]. + +%% -> {FileName, Module}; {string(), atom()} +compile_file_mod(Config) -> + NameL = lists:concat([?TESTMODULE, "_", ?testcase]), + Name = list_to_atom(NameL), + File = filename(NameL ++ ".erl", Config), + {File, Name}. + +filename(Name, Config) when is_atom(Name) -> + filename(atom_to_list(Name), Config); +filename(Name, Config) -> + filename:join(?privdir, Name). + +pps() -> + {port_list(), process_list()}. + +port_list() -> + [{P,safe_second_element(erlang:port_info(P, name))} || + P <- erlang:ports()]. + +process_list() -> + [{P,process_info(P, registered_name), + safe_second_element(process_info(P, initial_call))} || + P <- processes(), is_process_alive(P)]. + +safe_second_element({_,Info}) -> Info; +safe_second_element(Other) -> Other. + +warnings(File, Ws) -> + case lists:append([W || {F, W} <- Ws, F =:= File]) of + [] -> []; + L -> {warnings, L} + end. + +expected(Test, Expected, Got, File) -> + ?t:format("~nTest ~p failed. ", [Test]), + expected(Expected, Got, File). + +expected(Expected, Got, File) -> + ?t:format("Expected~n ~p~n, but got~n ~p~n", [Expected, Got]), + fail(File). + +fail(Source) -> + io:format("failed~n"), + ?t:fail({failed,testcase,on,Source}). + +%% Copied from global_SUITE.erl. + +start_node_rel(Name, Rel, How) -> + {Release, Compat} = case Rel of + this -> + {[this], "+R8"}; + Rel when is_atom(Rel) -> + {[{release, atom_to_list(Rel)}], ""}; + RelList -> + {RelList, ""} + end, + ?line Pa = filename:dirname(code:which(?MODULE)), + ?line Res = test_server:start_node(Name, How, + [{args, + Compat ++ + " -kernel net_setuptime 100 " + " -pa " ++ Pa}, + {erl, Release}]), + Res. + +stop_node(Node) -> + ?line ?t:stop_node(Node). + +install_error_logger() -> + error_logger:add_report_handler(?MODULE, self()). + +uninstall_error_logger() -> + error_logger:delete_report_handler(?MODULE). + +read_error_logger() -> + receive + {error, Why} -> + {error, Why}; + {info, Why} -> + {info, Why}; + {error, Pid, Tuple} -> + {error, Pid, Tuple} + after 1000 -> + ?line io:format("No reply after 1 s\n", []), + ?line ?t:fail() + end. + +%%----------------------------------------------------------------- +%% The error_logger handler used. +%% (Copied from stdlib/test/proc_lib_SUITE.erl.) +%%----------------------------------------------------------------- +init(Tester) -> + {ok, Tester}. + +handle_event({error, _GL, {_Pid, _Msg, [Why, _]}}, Tester) + when is_atom(Why) -> + Tester ! {error, Why}, + {ok, Tester}; +handle_event({error, _GL, {_Pid, _Msg, [P, T]}}, Tester) when is_pid(P) -> + Tester ! {error, P, T}, + {ok, Tester}; +handle_event({info_msg, _GL, {_Pid, _Msg, [Why, _]}}, Tester) -> + Tester ! {info, Why}, + {ok, Tester}; +handle_event(_Event, State) -> + {ok, State}. + +handle_info(_, State) -> + {ok, State}. + +handle_call(_Query, State) -> {ok, {error, bad_query}, State}. + +terminate(_Reason, State) -> + State. |