[wip] implement $data operator in mango_selector:match

Author: jcoglan

src/mango/src/mango_selector.erl

@@ -28,7 +28,8 @@
     cmp,
     verbose = false,
     negate = false,
-    path = []
+    path = [],
+    stack = []
 }).
 
 -record(failure, {
@@ -426,6 +427,22 @@ match({[]}, _, #ctx{verbose = false}) ->
     true;
 match({[]}, _, #ctx{verbose = true}) ->
     [];
+% Resolve $data lookups before evaluating the surrounding operator
+match({[{Op, {[{<<"$data">>, Path}]}}]}, Value, #ctx{stack = Stack, verbose = Verbose} = Ctx) ->
+    case mango_doc:get_field_from_stack(Path, Stack) of
+        not_found ->
+            case Verbose of
+                true -> [#failure{op = data, type = not_found, ctx = Ctx#ctx{path = Path}}];
+                false -> false
+            end;
+        bad_path ->
+            case Verbose of
+                true -> [#failure{op = data, type = bad_path, ctx = Ctx#ctx{path = Path}}];
+                false -> false
+            end;
+        Found ->
+            match({[{Op, Found}]}, Value, Ctx)
+    end;
 % We need to treat an empty array as always true. This will be applied
 % for $or, $in, $all, $nin as well.
 match({[{<<"$and">>, []}]}, _, #ctx{verbose = false}) ->
@@ -710,28 +727,28 @@ match({[{<<"$", _/binary>> = Op, _}]}, _, _) ->
 % We need to traverse value to find field. The call to
 % mango_doc:get_field/2 may return either not_found or
 % bad_path in which case matching fails.
-match({[{Field, Cond}]}, Value, #ctx{verbose = Verb, path = Path} = Ctx) ->
+match({[{Field, Cond}]}, Value, #ctx{verbose = Verb, path = Path, stack = Stack} = Ctx) ->
     InnerCtx = Ctx#ctx{path = [Field | Path]},
-    case mango_doc:get_field(Value, Field) of
-        not_found when Cond == {[{<<"$exists">>, false}]} ->
+    case mango_doc:get_field_with_stack(Value, Field, Stack) of
+        {not_found, _} when Cond == {[{<<"$exists">>, false}]} ->
             case Verb of
                 true -> [];
                 false -> true
             end;
-        not_found ->
+        {not_found, _} ->
             case Verb of
                 true -> [#failure{op = field, type = not_found, ctx = InnerCtx}];
                 false -> false
             end;
-        bad_path ->
+        {bad_path, _} ->
             case Verb of
                 true -> [#failure{op = field, type = bad_path, ctx = InnerCtx}];
                 false -> false
             end;
-        SubValue when Field == <<"_id">> ->
-            match(Cond, SubValue, InnerCtx#ctx{cmp = fun mango_json:cmp_raw/2});
-        SubValue ->
-            match(Cond, SubValue, InnerCtx)
+        {SubValue, NewStack} when Field == <<"_id">> ->
+            match(Cond, SubValue, InnerCtx#ctx{cmp = fun mango_json:cmp_raw/2, stack = NewStack});
+        {SubValue, NewStack} ->
+            match(Cond, SubValue, InnerCtx#ctx{stack = NewStack})
     end;
 match({[_, _ | _] = _Props} = Sel, _Value, _Ctx) ->
     error({unnormalized_selector, Sel}).
@@ -1933,6 +1950,68 @@ match_object_test() ->
     ?assertEqual(true, match_int(SelShort, Doc4)),
     ?assertEqual(false, match_int(SelShort, Doc5)).
 
+match_data_test() ->
+    SelAbs = normalize({[{<<"a">>, {[{<<"$gt">>, {[{<<"$data">>, <<"b">>}]}}]}}]}),
+    ?assertEqual(true, match_int(SelAbs, {[{<<"a">>, 2}, {<<"b">>, 1}]})),
+    ?assertEqual(false, match_int(SelAbs, {[{<<"a">>, 2}, {<<"b">>, 2}]})),
+
+    ?assertEqual(false, match_int(SelAbs, {[{<<"a">>, 2}]})),
+    ?assertMatch(
+        [#failure{op = data, type = not_found, params = [], ctx = #ctx{path = [<<"b">>]}}],
+        match_int(SelAbs, {[{<<"a">>, 2}]}, true)
+    ),
+
+    ?assertEqual(false, match_int(SelAbs, {[{<<"b">>, 2}]})),
+    ?assertMatch(
+        [#failure{op = field, type = not_found, params = [], ctx = #ctx{path = [<<"a">>]}}],
+        match_int(SelAbs, {[{<<"b">>, 2}]}, true)
+    ),
+
+    SelRel = normalize({[{<<"a.b">>, {[{<<"$gt">>, {[{<<"$data">>, <<".c">>}]}}]}}]}),
+    ?assertEqual(true, match_int(SelRel, {[{<<"a">>, {[{<<"b">>, 2}, {<<"c">>, 1}]}}]})),
+    ?assertEqual(false, match_int(SelRel, {[{<<"a">>, {[{<<"b">>, 2}, {<<"c">>, 2}]}}]})),
+
+    SelRelOutOfBounds = normalize({[{<<"a">>, {[{<<"$gt">>, {[{<<"$data">>, <<"..b">>}]}}]}}]}),
+    ?assertEqual(false, match_int(SelRelOutOfBounds, {[{<<"a">>, 1}]})),
+
+    SelRelAllMatch = normalize(
+        {[
+            {<<"a">>,
+                {[
+                    {<<"$allMatch">>,
+                        {[
+                            {<<"b">>, {[{<<"$gt">>, {[{<<"$data">>, <<".c">>}]}}]}}
+                        ]}}
+                ]}}
+        ]}
+    ),
+    ?assertEqual(
+        true,
+        match_int(
+            SelRelAllMatch,
+            {[
+                {<<"a">>, [
+                    {[{<<"b">>, 2}, {<<"c">>, 1}]},
+                    {[{<<"b">>, 5}, {<<"c">>, 3}]},
+                    {[{<<"b">>, 7}, {<<"c">>, 6}]}
+                ]}
+            ]}
+        )
+    ),
+    ?assertEqual(
+        false,
+        match_int(
+            SelRelAllMatch,
+            {[
+                {<<"a">>, [
+                    {[{<<"b">>, 2}, {<<"c">>, 1}]},
+                    {[{<<"b">>, 2}, {<<"c">>, 3}]},
+                    {[{<<"b">>, 7}, {<<"c">>, 6}]}
+                ]}
+            ]}
+        )
+    ).
+
 match_and_test() ->
     % $and with an empty array matches anything
     SelEmpty = normalize({[{<<"x">>, {[{<<"$and">>, []}]}}]}),

test/elixir/test/config/suite.elixir

@@ -524,6 +524,7 @@
     "converting a Mango VDU to JavaScript updates its effects",
     "deleting a Mango VDU removes its effects",
     "Mango VDU rejects a doc if any existing ddoc fails to match",
+    "Mango VDU allows comparisons via $data",
   ],
   "SecurityValidationTest": [
     "Author presence and user security",

test/elixir/test/validate_doc_update_test.exs

@@ -212,4 +212,45 @@ defmodule ValidateDocUpdateTest do
     assert resp.status_code == 403
     assert resp.body["error"] == "forbidden"
   end
+
+  @tag :with_db
+  test "Mango VDU allows comparisons via $data", context do
+    db = context[:db_name]
+
+    resp = Couch.put("/#{db}/_design/mango-test", body: %{
+      language: "query",
+
+      validate_doc_update: %{
+        "$or" => [
+          %{ "oldDoc" => :null },
+          %{ "oldDoc.tags" => %{ "$size" => 0 } },
+          %{ "newDoc.tags" => %{ "$all" => %{ "$data" => "oldDoc.tags" } } }
+        ]
+      }
+    })
+    assert resp.status_code == 201
+
+    resp = Couch.put("/#{db}/doc", body: %{
+      "tags" => ["a"]
+    })
+    assert resp.status_code == 201
+    rev = resp.body["rev"]
+
+    resp = Couch.put("/#{db}/doc", query: %{rev: rev}, body: %{
+      "tags" => ["a", "b"]
+    })
+    assert resp.status_code == 201
+    rev = resp.body["rev"]
+
+    resp = Couch.put("/#{db}/doc", query: %{rev: rev}, body: %{
+      "tags" => ["b", "a", "c"]
+    })
+    assert resp.status_code == 201
+    rev = resp.body["rev"]
+
+    resp = Couch.put("/#{db}/doc", query: %{rev: rev}, body: %{
+      "tags" => ["b", "c"]
+    })
+    assert resp.status_code == 403
+  end
 end