| % Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| % use this file except in compliance with the License. You may obtain a copy of |
| % the License at |
| % |
| % http://www.apache.org/licenses/LICENSE-2.0 |
| % |
| % Unless required by applicable law or agreed to in writing, software |
| % distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| % WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| % License for the specific language governing permissions and limitations under |
| % the License. |
| |
| -module(mango_selector_text). |
| |
| -export([ |
| convert/1, |
| convert/2, |
| |
| append_sort_type/2 |
| ]). |
| |
| -include("mango.hrl"). |
| |
| %% Regex for <<"\\.">> |
| -define(PERIOD, "\\."). |
| |
| -spec convert(SelectorObject) -> LuceneQueryString when |
| SelectorObject :: any(), |
| LuceneQueryString :: binary(). |
| convert(Object) -> |
| TupleTree = convert([], Object), |
| iolist_to_binary(to_query(TupleTree)). |
| |
| -spec convert(CurrentPath, SelectorObject) -> abstract_text_selector() when |
| CurrentPath :: [binary()], |
| SelectorObject :: any(). |
| convert(Path, {[{<<"$and">>, Args}]}) -> |
| Parts = [convert(Path, Arg) || Arg <- Args], |
| {op_and, Parts}; |
| convert(Path, {[{<<"$or">>, Args}]}) -> |
| Parts = [convert(Path, Arg) || Arg <- Args], |
| {op_or, Parts}; |
| convert(Path, {[{<<"$not">>, Arg}]}) -> |
| {op_not, {field_exists_query(Path), convert(Path, Arg)}}; |
| convert(Path, {[{<<"$default">>, Arg}]}) -> |
| {op_field, {_, Query}} = convert(Path, Arg), |
| {op_default, Query}; |
| % The $text operator specifies a Lucene syntax query |
| % so we just pull it in directly. |
| convert(Path, {[{<<"$text">>, Query}]}) when is_binary(Query) -> |
| {op_field, {make_field(Path, Query), value_str(Query)}}; |
| % The MongoDB docs for $all are super confusing and read more |
| % like they screwed up the implementation of this operator |
| % and then just documented it as a feature. |
| % |
| % This implementation will match the behavior as closely as |
| % possible based on the available docs but we'll need to have |
| % the testing team validate how MongoDB handles edge conditions |
| convert(Path, {[{<<"$all">>, Args}]}) -> |
| case Args of |
| [Values] when is_list(Values) -> |
| % If Args is a single element array then we have to |
| % either match if Path is that array or if it contains |
| % the array as an element of an array (which isn't at all |
| % confusing). For Lucene to return us all possible matches |
| % that means we just need to search for each value in |
| % Path.[] and Path.[].[] and rely on our filtering to limit |
| % the results properly. |
| Fields1 = convert(Path, {[{<<"$eq">>, Values}]}), |
| Fields2 = convert([<<"[]">> | Path], {[{<<"$eq">>, Values}]}), |
| {op_or, [Fields1, Fields2]}; |
| _ -> |
| % Otherwise the $all operator is equivalent to an $and |
| % operator so we treat it as such. |
| convert([<<"[]">> | Path], {[{<<"$and">>, Args}]}) |
| end; |
| % The $elemMatch Lucene query is not an exact translation |
| % as we can't enforce that the matches are all for the same |
| % item in an array. We just rely on the final selector match |
| % to filter out anything that doesn't match. The only trick |
| % is that we have to add the `[]` path element since the docs |
| % say this has to match against an array. |
| convert(Path, {[{<<"$elemMatch">>, Arg}]}) -> |
| convert([<<"[]">> | Path], Arg); |
| convert(Path, {[{<<"$allMatch">>, Arg}]}) -> |
| convert([<<"[]">> | Path], Arg); |
| % Our comparison operators are fairly straight forward |
| convert(Path, {[{<<"$lt">>, Arg}]}) when |
| is_list(Arg); |
| is_tuple(Arg); |
| Arg =:= null |
| -> |
| field_exists_query(Path); |
| convert(Path, {[{<<"$lt">>, Arg}]}) -> |
| {op_field, {make_field(Path, Arg), range(lt, Arg)}}; |
| convert(Path, {[{<<"$lte">>, Arg}]}) when |
| is_list(Arg); |
| is_tuple(Arg); |
| Arg =:= null |
| -> |
| field_exists_query(Path); |
| convert(Path, {[{<<"$lte">>, Arg}]}) -> |
| {op_field, {make_field(Path, Arg), range(lte, Arg)}}; |
| %% This is for indexable_fields |
| convert(Path, {[{<<"$eq">>, Arg}]}) when Arg =:= null -> |
| {op_null, {make_field(Path, Arg), value_str(Arg)}}; |
| convert(Path, {[{<<"$eq">>, Args}]}) when is_list(Args) -> |
| Path0 = [<<"[]">> | Path], |
| LPart = {op_field, {make_field(Path0, length), value_str(length(Args))}}, |
| Parts0 = [convert(Path0, {[{<<"$eq">>, Arg}]}) || Arg <- Args], |
| Parts = [LPart | Parts0], |
| {op_and, Parts}; |
| convert(Path, {[{<<"$eq">>, {_} = Arg}]}) -> |
| convert(Path, Arg); |
| convert(Path, {[{<<"$eq">>, Arg}]}) -> |
| {op_field, {make_field(Path, Arg), value_str(Arg)}}; |
| convert(Path, {[{<<"$ne">>, Arg}]}) -> |
| {op_not, {field_exists_query(Path), convert(Path, {[{<<"$eq">>, Arg}]})}}; |
| convert(Path, {[{<<"$gte">>, Arg}]}) when |
| is_list(Arg); |
| is_tuple(Arg); |
| Arg =:= null |
| -> |
| field_exists_query(Path); |
| convert(Path, {[{<<"$gte">>, Arg}]}) -> |
| {op_field, {make_field(Path, Arg), range(gte, Arg)}}; |
| convert(Path, {[{<<"$gt">>, Arg}]}) when |
| is_list(Arg); |
| is_tuple(Arg); |
| Arg =:= null |
| -> |
| field_exists_query(Path); |
| convert(Path, {[{<<"$gt">>, Arg}]}) -> |
| {op_field, {make_field(Path, Arg), range(gt, Arg)}}; |
| convert(Path, {[{<<"$in">>, Args}]}) -> |
| {op_or, convert_in(Path, Args)}; |
| convert(Path, {[{<<"$nin">>, Args}]}) -> |
| {op_not, {field_exists_query(Path), convert(Path, {[{<<"$in">>, Args}]})}}; |
| convert(Path, {[{<<"$exists">>, ShouldExist}]}) -> |
| FieldExists = field_exists_query(Path), |
| case ShouldExist of |
| true -> FieldExists; |
| false -> {op_not, {FieldExists, false}} |
| end; |
| % We're not checking the actual type here, just looking for |
| % anything that has a possibility of matching by checking |
| % for the field name. We use the same logic for $exists on |
| % the actual query. |
| convert(Path, {[{<<"$type">>, _}]}) -> |
| field_exists_query(Path); |
| convert(Path, {[{<<"$mod">>, _}]}) -> |
| field_exists_query(Path, "number"); |
| % The lucene regular expression engine does not use java's regex engine but |
| % instead a custom implementation. The syntax is therefore different, so we do |
| % would get different behavior than our view indexes. To be consistent, we will |
| % simply return docs for fields that exist and then run our match filter. |
| % |
| % It has a dedicated type so that `mango_idx_text:indexable_fields/1` |
| % could handle this case properly. |
| convert(Path, {[{<<"$regex">>, _}]}) -> |
| {op_regex, path_str(Path)}; |
| convert(Path, {[{<<"$size">>, Arg}]}) -> |
| {op_field, {make_field([<<"[]">> | Path], length), value_str(Arg)}}; |
| % All other operators are internal assertion errors for |
| % matching because we either should've removed them during |
| % normalization or something else broke. |
| convert(_Path, {[{<<"$", _/binary>> = Op, _}]}) -> |
| ?MANGO_ERROR({invalid_operator, Op}); |
| % We've hit a field name specifier. Check if the field name is accessing |
| % arrays. Convert occurrences of element position references to .[]. Then we |
| % need to break the name into path parts and continue our conversion. |
| convert(Path, {[{Field0, Cond}]}) -> |
| {ok, PP0} = |
| case Field0 of |
| <<>> -> |
| {ok, []}; |
| _ -> |
| mango_util:parse_field(Field0) |
| end, |
| % Later on, we perform a lucene_escape_user call on the |
| % final Path, which calls parse_field again. Calling the function |
| % twice converts <<"a\\.b">> to [<<"a">>,<<"b">>]. This leads to |
| % an incorrect query since we need [<<"a.b">>]. Without breaking |
| % our escaping mechanism, we simply revert this first parse_field |
| % effect and replace instances of "." to "\\.". |
| MP = mango_util:cached_re(mango_period, ?PERIOD), |
| PP1 = [ |
| re:replace( |
| P, |
| MP, |
| <<"\\\\.">>, |
| [global, {return, binary}] |
| ) |
| || P <- PP0 |
| ], |
| {PP2, HasInteger} = replace_array_indexes(PP1, [], false), |
| NewPath = PP2 ++ Path, |
| case HasInteger of |
| true -> |
| OldPath = lists:reverse(PP1, Path), |
| OldParts = convert(OldPath, Cond), |
| NewParts = convert(NewPath, Cond), |
| {op_or, [OldParts, NewParts]}; |
| false -> |
| convert(NewPath, Cond) |
| end; |
| %% For $in |
| convert(Path, Val) when is_binary(Val); is_number(Val); is_boolean(Val) -> |
| {op_field, {make_field(Path, Val), value_str(Val)}}; |
| % Anything else is a bad selector. |
| convert(_Path, {Props} = Sel) when length(Props) > 1 -> |
| erlang:error({unnormalized_selector, Sel}). |
| |
| to_query_nested(Args) -> |
| QueryArgs = lists:map(fun to_query/1, Args), |
| % removes empty queries that result from selectors with empty arrays |
| FilterFun = fun(A) -> A =/= [] andalso A =/= "()" end, |
| lists:filter(FilterFun, QueryArgs). |
| |
| -spec to_query(abstract_text_selector()) -> LuceneQueryStringPieces when |
| LuceneQueryStringPieces :: [binary()]. |
| to_query({op_and, []}) -> |
| []; |
| to_query({op_and, Args}) when is_list(Args) -> |
| case to_query_nested(Args) of |
| [] -> []; |
| QueryArgs -> ["(", mango_util:join(<<" AND ">>, QueryArgs), ")"] |
| end; |
| to_query({op_or, []}) -> |
| []; |
| to_query({op_or, Args}) when is_list(Args) -> |
| case to_query_nested(Args) of |
| [] -> []; |
| QueryArgs -> ["(", mango_util:join(" OR ", QueryArgs), ")"] |
| end; |
| to_query({op_not, {ExistsQuery, Arg}}) when is_tuple(Arg) -> |
| case to_query(Arg) of |
| [] -> ["(", to_query(ExistsQuery), ")"]; |
| Query -> ["(", to_query(ExistsQuery), " AND NOT (", Query, "))"] |
| end; |
| %% For $exists:false |
| to_query({op_not, {ExistsQuery, false}}) -> |
| ["($fieldnames:/.*/ ", " AND NOT (", to_query(ExistsQuery), "))"]; |
| %% We escape : and / for now for values and all lucene chars for fieldnames |
| %% This needs to be resolved. |
| to_query({op_field, {Name, Value}}) -> |
| NameBin = iolist_to_binary(Name), |
| ["(", mango_util:lucene_escape_user(NameBin), ":", Value, ")"]; |
| %% This is for indexable_fields |
| to_query({op_null, {Name, Value}}) -> |
| NameBin = iolist_to_binary(Name), |
| ["(", mango_util:lucene_escape_user(NameBin), ":", Value, ")"]; |
| to_query({op_fieldname, {Name, Wildcard}}) -> |
| NameBin = iolist_to_binary(Name), |
| ["($fieldnames:", mango_util:lucene_escape_user(NameBin), Wildcard, ")"]; |
| %% This is for indexable_fields |
| to_query({op_regex, Name}) -> |
| NameBin = iolist_to_binary([Name, ":"]), |
| ["($fieldnames:", mango_util:lucene_escape_user(NameBin), "string)"]; |
| to_query({op_default, Value}) -> |
| ["($default:", Value, ")"]. |
| |
| %% We match on fieldname and fieldname.[] |
| convert_in(Path, Args) -> |
| Path0 = [<<"[]">> | Path], |
| lists:map( |
| fun(Arg) -> |
| case Arg of |
| {Object} -> |
| Parts = lists:map( |
| fun(SubObject) -> |
| Fields1 = convert(Path, {[SubObject]}), |
| Fields2 = convert(Path0, {[SubObject]}), |
| {op_or, [Fields1, Fields2]} |
| end, |
| Object |
| ), |
| {op_or, Parts}; |
| SingleVal -> |
| Fields1 = {op_field, {make_field(Path, SingleVal), value_str(SingleVal)}}, |
| Fields2 = {op_field, {make_field(Path0, SingleVal), value_str(SingleVal)}}, |
| {op_or, [Fields1, Fields2]} |
| end |
| end, |
| Args |
| ). |
| |
| make_field(Path, length) -> |
| [path_str(Path), <<":length">>]; |
| make_field(Path, Arg) -> |
| [path_str(Path), <<":">>, type_str(Arg)]. |
| |
| range(lt, Arg) -> |
| Min = get_range(min, Arg), |
| [<<"[", Min/binary, " TO ">>, value_str(Arg), <<"}">>]; |
| range(lte, Arg) -> |
| Min = get_range(min, Arg), |
| [<<"[", Min/binary, " TO ">>, value_str(Arg), <<"]">>]; |
| range(gte, Arg) -> |
| Max = get_range(max, Arg), |
| [<<"[">>, value_str(Arg), <<" TO ", Max/binary, "]">>]; |
| range(gt, Arg) -> |
| Max = get_range(max, Arg), |
| [<<"{">>, value_str(Arg), <<" TO ", Max/binary, "]">>]. |
| |
| get_range(min, Arg) when is_number(Arg) -> |
| <<"-Infinity">>; |
| get_range(min, _Arg) -> |
| <<"\"\"">>; |
| get_range(max, Arg) when is_number(Arg) -> |
| <<"Infinity">>; |
| get_range(max, _Arg) -> |
| <<"\u0x10FFFF">>. |
| |
| field_exists_query(Path) -> |
| % We specify two here for :* and .* so that we don't incorrectly |
| % match a path foo.name against foo.name_first (if were to just |
| % append * instead). |
| Parts = [ |
| % We need to remove the period from the path list to indicate that it is |
| % a path separator. We escape the colon because it is not used as a |
| % separator and we escape colons in field names. |
| {op_fieldname, {[path_str(Path), ":"], "*"}}, |
| {op_fieldname, {[path_str(Path)], ".*"}} |
| ], |
| {op_or, Parts}. |
| |
| field_exists_query(Path, Type) -> |
| {op_fieldname, {[path_str(Path), ":"], Type}}. |
| |
| path_str(Path) -> |
| path_str(Path, []). |
| |
| path_str([], Acc) -> |
| Acc; |
| path_str([Part], Acc) -> |
| % No reverse because Path is backwards |
| % during recursion of convert. |
| [Part | Acc]; |
| path_str([Part | Rest], Acc) -> |
| case Part of |
| % do not append a period if Part is blank |
| <<>> -> |
| path_str(Rest, [Acc]); |
| _ -> |
| path_str(Rest, [<<".">>, Part | Acc]) |
| end. |
| |
| type_str(Value) when is_number(Value) -> |
| <<"number">>; |
| type_str(Value) when is_boolean(Value) -> |
| <<"boolean">>; |
| type_str(Value) when is_binary(Value) -> |
| <<"string">>; |
| type_str(null) -> |
| <<"null">>. |
| |
| value_str(Value) when is_binary(Value) -> |
| case mango_util:is_number_string(Value) of |
| true -> |
| <<"\"", Value/binary, "\"">>; |
| false -> |
| Escaped = mango_util:lucene_escape_query_value(Value), |
| <<"\"", Escaped/binary, "\"">> |
| end; |
| value_str(Value) when is_integer(Value) -> |
| list_to_binary(integer_to_list(Value)); |
| value_str(Value) when is_float(Value) -> |
| list_to_binary(float_to_list(Value)); |
| value_str(true) -> |
| <<"true">>; |
| value_str(false) -> |
| <<"false">>; |
| value_str(null) -> |
| <<"true">>. |
| |
| append_sort_type(RawSortField, Selector) -> |
| EncodeField = mango_util:lucene_escape_user(RawSortField), |
| String = mango_util:has_suffix(EncodeField, <<"_3astring">>), |
| Number = mango_util:has_suffix(EncodeField, <<"_3anumber">>), |
| case {String, Number} of |
| {true, _} -> |
| <<EncodeField/binary, "<string>">>; |
| {_, true} -> |
| <<EncodeField/binary, "<number>">>; |
| _ -> |
| Type = get_sort_type(RawSortField, Selector), |
| <<EncodeField/binary, Type/binary>> |
| end. |
| |
| get_sort_type(Field, Selector) -> |
| Types = get_sort_types(Field, Selector, []), |
| case lists:usort(Types) of |
| [str] -> <<"_3astring<string>">>; |
| [num] -> <<"_3anumber<number>">>; |
| _ -> ?MANGO_ERROR({text_sort_error, Field}) |
| end. |
| |
| get_sort_types(Field, {[{Field, {[{<<"$", _/binary>>, Cond}]}}]}, Acc) when |
| is_binary(Cond) |
| -> |
| [str | Acc]; |
| get_sort_types(Field, {[{Field, {[{<<"$", _/binary>>, Cond}]}}]}, Acc) when |
| is_number(Cond) |
| -> |
| [num | Acc]; |
| get_sort_types(Field, {[{_, Cond}]}, Acc) when is_list(Cond) -> |
| lists:foldl( |
| fun(Arg, InnerAcc) -> |
| get_sort_types(Field, Arg, InnerAcc) |
| end, |
| Acc, |
| Cond |
| ); |
| get_sort_types(Field, {[{_, Cond}]}, Acc) when is_tuple(Cond) -> |
| get_sort_types(Field, Cond, Acc); |
| get_sort_types(_Field, _, Acc) -> |
| Acc. |
| |
| replace_array_indexes([], NewPartsAcc, HasIntAcc) -> |
| {NewPartsAcc, HasIntAcc}; |
| replace_array_indexes([Part | Rest], NewPartsAcc, HasIntAcc) -> |
| {NewPart, HasInt} = |
| try |
| _ = list_to_integer(binary_to_list(Part)), |
| {<<"[]">>, true} |
| catch |
| _:_ -> |
| {Part, false} |
| end, |
| replace_array_indexes( |
| Rest, |
| [NewPart | NewPartsAcc], |
| HasInt or HasIntAcc |
| ). |
| |
| -ifdef(TEST). |
| -include_lib("eunit/include/eunit.hrl"). |
| |
| convert_selector(Selector) -> |
| convert([], test_util:as_selector(Selector)). |
| |
| convert_fields_test() -> |
| ?assertEqual( |
| {op_null, {[[<<"field">>], <<":">>, <<"null">>], <<"true">>}}, |
| convert_selector(#{<<"field">> => null}) |
| ), |
| ?assertEqual( |
| {op_field, {[[<<"field">>], <<":">>, <<"boolean">>], <<"true">>}}, |
| convert_selector(#{<<"field">> => true}) |
| ), |
| ?assertEqual( |
| {op_field, {[[<<"field">>], <<":">>, <<"number">>], <<"42">>}}, |
| convert_selector(#{<<"field">> => 42}) |
| ), |
| ?assertEqual( |
| {op_field, {[[<<"field">>], <<":">>, <<"string">>], <<"\"value\"">>}}, |
| convert_selector(#{<<"field">> => <<"value">>}) |
| ), |
| ?assertEqual( |
| {op_and, [ |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":length">>], <<"3">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"1">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"2">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"3">>}} |
| ]}, |
| convert_selector(#{<<"field">> => [1, 2, 3]}) |
| ), |
| ?assertEqual( |
| {op_field, { |
| [[<<"field1">>, <<".">>, <<"field2">>], <<":">>, <<"string">>], <<"\"value\"">> |
| }}, |
| convert_selector(#{<<"field1">> => #{<<"field2">> => <<"value">>}}) |
| ), |
| ?assertEqual( |
| {op_and, [ |
| {op_field, {[[<<"field2">>], <<":">>, <<"string">>], <<"\"value2\"">>}}, |
| {op_field, {[[<<"field1">>], <<":">>, <<"string">>], <<"\"value1\"">>}} |
| ]}, |
| convert_selector(#{<<"field1">> => <<"value1">>, <<"field2">> => <<"value2">>}) |
| ). |
| |
| convert_default_test() -> |
| ?assertEqual( |
| {op_default, <<"\"text\"">>}, |
| convert_selector(#{<<"$default">> => #{<<"$text">> => <<"text">>}}) |
| ). |
| |
| convert_lt_test() -> |
| ?assertEqual( |
| {op_field, |
| {[[<<"field">>], <<":">>, <<"number">>], [<<"[-Infinity TO ">>, <<"42">>, <<"}">>]}}, |
| convert_selector(#{<<"field">> => #{<<"$lt">> => 42}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$lt">> => [1, 2, 3]}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$lt">> => null}}) |
| ). |
| |
| convert_lte_test() -> |
| ?assertEqual( |
| {op_field, |
| {[[<<"field">>], <<":">>, <<"number">>], [<<"[-Infinity TO ">>, <<"42">>, <<"]">>]}}, |
| convert_selector(#{<<"field">> => #{<<"$lte">> => 42}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$lte">> => [1, 2, 3]}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$lte">> => null}}) |
| ). |
| |
| convert_eq_test() -> |
| ?assertEqual( |
| {op_field, {[[<<"field">>], <<":">>, <<"number">>], <<"42">>}}, |
| convert_selector(#{<<"field">> => #{<<"$eq">> => 42}}) |
| ), |
| ?assertEqual( |
| {op_and, [ |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":length">>], <<"3">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"1">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"2">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"3">>}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$eq">> => [1, 2, 3]}}) |
| ), |
| ?assertEqual( |
| {op_null, {[[<<"field">>], <<":">>, <<"null">>], <<"true">>}}, |
| convert_selector(#{<<"field">> => #{<<"$eq">> => null}}) |
| ). |
| |
| convert_ne_test() -> |
| ?assertEqual( |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| {op_field, {[[<<"field">>], <<":">>, <<"number">>], <<"42">>}} |
| }}, |
| convert_selector(#{<<"field">> => #{<<"$ne">> => 42}}) |
| ). |
| |
| convert_gte_test() -> |
| ?assertEqual( |
| {op_field, |
| {[[<<"field">>], <<":">>, <<"number">>], [<<"[">>, <<"42">>, <<" TO Infinity]">>]}}, |
| convert_selector(#{<<"field">> => #{<<"$gte">> => 42}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$gte">> => [1, 2, 3]}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$gte">> => null}}) |
| ). |
| |
| convert_gt_test() -> |
| ?assertEqual( |
| {op_field, |
| {[[<<"field">>], <<":">>, <<"number">>], [<<"{">>, <<"42">>, <<" TO Infinity]">>]}}, |
| convert_selector(#{<<"field">> => #{<<"$gt">> => 42}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$gt">> => [1, 2, 3]}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$gt">> => null}}) |
| ). |
| |
| convert_all_test() -> |
| ?assertEqual( |
| {op_and, [ |
| {op_field, { |
| [[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"string">>], <<"\"value1\"">> |
| }}, |
| {op_field, { |
| [[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"string">>], <<"\"value2\"">> |
| }} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$all">> => [<<"value1">>, <<"value2">>]}}) |
| ). |
| |
| convert_elemMatch_test() -> |
| ?assertEqual( |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"string">>], <<"\"value\"">>}}, |
| convert_selector(#{<<"field">> => #{<<"$elemMatch">> => #{<<"$eq">> => <<"value">>}}}) |
| ). |
| |
| convert_allMatch_test() -> |
| ?assertEqual( |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"string">>], <<"\"value\"">>}}, |
| convert_selector(#{<<"field">> => #{<<"$allMatch">> => #{<<"$eq">> => <<"value">>}}}) |
| ). |
| |
| convert_keyMapMatch_test() -> |
| ?assertThrow( |
| {mango_error, mango_selector_text, {invalid_operator, <<"$keyMapMatch">>}}, |
| convert_selector(#{<<"field">> => #{<<"$keyMapMatch">> => #{<<"key">> => <<"value">>}}}) |
| ). |
| |
| convert_in_test() -> |
| ?assertEqual( |
| {op_or, []}, |
| convert_selector(#{<<"field">> => #{<<"$in">> => []}}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_or, [ |
| {op_field, {[[<<"field">>], <<":">>, <<"string">>], <<"\"value1\"">>}}, |
| {op_field, { |
| [[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"string">>], <<"\"value1\"">> |
| }} |
| ]}, |
| {op_or, [ |
| {op_field, {[[<<"field">>], <<":">>, <<"string">>], <<"\"value2\"">>}}, |
| {op_field, { |
| [[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"string">>], <<"\"value2\"">> |
| }} |
| ]} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$in">> => [<<"value1">>, <<"value2">>]}}) |
| ). |
| |
| convert_nin_test() -> |
| ?assertEqual( |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| {op_or, []} |
| }}, |
| convert_selector(#{<<"field">> => #{<<"$nin">> => []}}) |
| ), |
| ?assertEqual( |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| {op_or, [ |
| {op_or, [ |
| {op_field, {[[<<"field">>], <<":">>, <<"number">>], <<"1">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"1">>}} |
| ]}, |
| {op_or, [ |
| {op_field, {[[<<"field">>], <<":">>, <<"number">>], <<"2">>}}, |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":">>, <<"number">>], <<"2">>}} |
| ]} |
| ]} |
| }}, |
| convert_selector(#{<<"field">> => #{<<"$nin">> => [1, 2]}}) |
| ). |
| |
| convert_exists_test() -> |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$exists">> => true}}) |
| ), |
| ?assertEqual( |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| false |
| }}, |
| convert_selector(#{<<"field">> => #{<<"$exists">> => false}}) |
| ). |
| |
| convert_type_test() -> |
| ?assertEqual( |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| convert_selector(#{<<"field">> => #{<<"$type">> => <<"string">>}}) |
| ). |
| |
| convert_mod_test() -> |
| ?assertEqual( |
| {op_fieldname, {[[<<"field">>], ":"], "number"}}, |
| convert_selector(#{<<"field">> => #{<<"$mod">> => [2, 0]}}) |
| ). |
| |
| convert_regex_test() -> |
| ?assertEqual( |
| {op_regex, [<<"field">>]}, |
| convert_selector(#{<<"field">> => #{<<"$regex">> => <<".*">>}}) |
| ). |
| |
| convert_size_test() -> |
| ?assertEqual( |
| {op_field, {[[<<"field">>, <<".">>, <<"[]">>], <<":length">>], <<"6">>}}, |
| convert_selector(#{<<"field">> => #{<<"$size">> => 6}}) |
| ). |
| |
| convert_not_test() -> |
| ?assertEqual( |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| {op_fieldname, {[[<<"field">>], ":"], "number"}} |
| }}, |
| convert_selector(#{<<"field">> => #{<<"$not">> => #{<<"$mod">> => [2, 0]}}}) |
| ). |
| |
| convert_and_test() -> |
| ?assertEqual( |
| {op_and, []}, |
| convert_selector(#{<<"$and">> => []}) |
| ), |
| ?assertEqual( |
| {op_and, [{op_field, {[[<<"field">>], <<":">>, <<"string">>], <<"\"value\"">>}}]}, |
| convert_selector(#{<<"$and">> => [#{<<"field">> => <<"value">>}]}) |
| ), |
| ?assertEqual( |
| {op_and, [ |
| {op_field, {[[<<"field1">>], <<":">>, <<"string">>], <<"\"value1\"">>}}, |
| {op_field, {[[<<"field2">>], <<":">>, <<"string">>], <<"\"value2\"">>}} |
| ]}, |
| convert_selector(#{ |
| <<"$and">> => [#{<<"field1">> => <<"value1">>}, #{<<"field2">> => <<"value2">>}] |
| }) |
| ). |
| |
| convert_or_test() -> |
| ?assertEqual( |
| {op_or, []}, |
| convert_selector(#{<<"$or">> => []}) |
| ), |
| ?assertEqual( |
| {op_or, [{op_field, {[[<<"field">>], <<":">>, <<"string">>], <<"\"value\"">>}}]}, |
| convert_selector(#{<<"$or">> => [#{<<"field">> => <<"value">>}]}) |
| ), |
| ?assertEqual( |
| {op_or, [ |
| {op_field, {[[<<"field1">>], <<":">>, <<"string">>], <<"\"value1\"">>}}, |
| {op_field, {[[<<"field2">>], <<":">>, <<"string">>], <<"\"value2\"">>}} |
| ]}, |
| convert_selector(#{ |
| <<"$or">> => [#{<<"field1">> => <<"value1">>}, #{<<"field2">> => <<"value2">>}] |
| }) |
| ). |
| |
| convert_nor_test() -> |
| ?assertEqual( |
| {op_and, []}, |
| convert_selector(#{<<"$nor">> => []}) |
| ), |
| ?assertEqual( |
| {op_and, [ |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field">>]], ".*"}} |
| ]}, |
| {op_field, {[[<<"field">>], <<":">>, <<"string">>], <<"\"value\"">>}} |
| }} |
| ]}, |
| convert_selector(#{<<"$nor">> => [#{<<"field">> => <<"value">>}]}) |
| ), |
| ?assertEqual( |
| {op_and, [ |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field1">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field1">>]], ".*"}} |
| ]}, |
| {op_field, {[[<<"field1">>], <<":">>, <<"string">>], <<"\"value1\"">>}} |
| }}, |
| {op_not, { |
| {op_or, [ |
| {op_fieldname, {[[<<"field2">>], ":"], "*"}}, |
| {op_fieldname, {[[<<"field2">>]], ".*"}} |
| ]}, |
| {op_field, {[[<<"field2">>], <<":">>, <<"string">>], <<"\"value2\"">>}} |
| }} |
| ]}, |
| convert_selector(#{ |
| <<"$nor">> => [#{<<"field1">> => <<"value1">>}, #{<<"field2">> => <<"value2">>}] |
| }) |
| ). |
| |
| to_query_test() -> |
| F = fun(S) -> iolist_to_binary(to_query(S)) end, |
| Input = {<<"name">>, <<"value">>}, |
| ?assertEqual(<<"(name:value)">>, F({op_field, Input})), |
| ?assertEqual( |
| <<"(name1.name2_3atype:value)">>, |
| F({op_field, {[[<<"name1">>, <<".">>, <<"name2">>], <<":">>, <<"type">>], <<"value">>}}) |
| ), |
| ?assertEqual(<<"(name:value)">>, F({op_null, Input})), |
| ?assertEqual(<<"($fieldnames:name_3astring)">>, F({op_regex, <<"name">>})), |
| ?assertEqual(<<"($fieldnames:name_3a.*)">>, F({op_fieldname, {<<"name">>, <<"_3a.*">>}})), |
| Arg1 = {op_default, <<"value">>}, |
| ?assertEqual(<<"($default:value)">>, F(Arg1)), |
| Arg2 = {op_field, Input}, |
| ?assertEqual(<<"($fieldnames:/.*/ AND NOT ((name:value)))">>, F({op_not, {Arg2, false}})), |
| ?assertEqual(<<"((name:value))">>, F({op_not, {Arg2, {op_and, []}}})), |
| ?assertEqual(<<"">>, F({op_and, []})), |
| ?assertEqual(<<"(($default:value))">>, F({op_and, [Arg1]})), |
| ?assertEqual(<<"(($default:value) AND (name:value))">>, F({op_and, [Arg1, Arg2]})), |
| ?assertEqual( |
| <<"(($default:value) AND (name:value))">>, F({op_and, [Arg1, {op_and, []}, Arg2]}) |
| ), |
| ?assertEqual(<<"">>, F({op_or, []})), |
| ?assertEqual(<<"(($default:value))">>, F({op_or, [Arg1]})), |
| ?assertEqual(<<"(($default:value) OR (name:value))">>, F({op_or, [Arg1, Arg2]})), |
| ?assertEqual(<<"(($default:value) OR (name:value))">>, F({op_or, [Arg1, Arg2, {op_or, []}]})). |
| -endif. |
