Evaluate typed queries over persistent maps

test/test_incremental.ml

@@ -0,0 +1,122 @@
+open Test_harness
+
+let row customer total = Value.VRecord ("order", [ ("customer", Value.VString customer); ("total", Value.VInt total) ])
+
+let input entries = List.mapi (fun index entry -> (index + 1, entry)) entries
+
+let run fixture_name entries =
+  let program = infer (read_fixture fixture_name) in
+  Interpret.program program (input entries)
+
+let run_text text entries =
+  let program = infer text in
+  Interpret.program program (input entries)
+
+let cases =
+  [
+    ( "the example query selects and projects rows",
+      fun () ->
+        let result =
+          run "expensive_order.delta"
+            [ row "Ada" 1500; row "Bo" 900; row "Lin" 2200 ]
+        in
+        check_equal_string "result" "(collection (1 (tuple \"Ada\" 300)) (3 (tuple \"Lin\" 440)))"
+          (Value.to_string result) );
+    ( "a filter that keeps nothing yields an empty collection",
+      fun () ->
+        let result = run "expensive_order.delta" [ row "Bo" 10 ] in
+        check_equal_string "empty" "(collection )" (Value.to_string result) );
+    ( "an empty input yields an empty collection and zero aggregates",
+      fun () ->
+        check_equal_string "no rows" "(collection )" (Value.to_string (run "expensive_order.delta" []));
+        check_equal_int "revenue" 0
+          (match run "revenue.delta" [] with Value.VInt total -> total | _ -> -1);
+        check_equal_int "count" 0
+          (match run "count_large.delta" [] with Value.VInt total -> total | _ -> -1) );
+    ( "revenue sums the taxed totals",
+      fun () ->
+        let result = run "revenue.delta" [ row "Ada" 1000; row "Bo" 250 ] in
+        check_equal_string "revenue" "250" (Value.to_string result) );
+    ( "count_large counts the retained rows",
+      fun () ->
+        let result = run "count_large.delta" [ row "Ada" 1000; row "Bo" 250; row "Lin" 501 ] in
+        check_equal_string "count" "2" (Value.to_string result) );
+    ( "negative values are preserved",
+      fun () ->
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> filter (fun r -> r < 0) |> sum\n"
+            [ Value.VInt (-5); Value.VInt 3; Value.VInt (-7) ]
+        in
+        check_equal_string "sum" "-12" (Value.to_string result) );
+    ( "integer division truncates towards zero",
+      fun () ->
+        let result = run_text "input rows : collection int\nquery q = rows |> map (fun r -> r / 3) |> sum\n"
+            [ Value.VInt 10; Value.VInt (-10) ]
+        in
+        check_equal_string "sum" "0" (Value.to_string result) );
+    ( "division by zero is a runtime error",
+      fun () ->
+        (try
+           ignore (run_text "input rows : collection int\nquery q = rows |> map (fun r -> 100 / r) |> sum\n"
+                     [ Value.VInt 5; Value.VInt 0 ]);
+           fail "division" "expected a runtime error"
+         with Division_by_zero -> check "raised" true) );
+    ( "the mapping expression runs only where the filter keeps rows",
+      fun () ->
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> filter (fun r -> r > 10) |> map (fun r -> 1000 / r) |> sum\n"
+            [ Value.VInt 5; Value.VInt 20 ]
+        in
+        check_equal_string "sum" "50" (Value.to_string result) );
+    ( "boolean operators short circuit",
+      fun () ->
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> count\n"
+            [ Value.VInt 1 ]
+        in
+        check_equal_string "count" "1" (Value.to_string result);
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> filter (fun r -> false && 1 / r > 0) |> count\n"
+            [ Value.VInt 0 ]
+        in
+        check_equal_string "short circuit and" "0" (Value.to_string result);
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> filter (fun r -> true || 1 / r > 0) |> count\n"
+            [ Value.VInt 0 ]
+        in
+        check_equal_string "short circuit or" "1" (Value.to_string result) );
+    ( "map preserves keys and filter keeps the original keys",
+      fun () ->
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> filter (fun r -> r > 1) |> map (fun r -> r * 10)\n"
+            [ Value.VInt 1; Value.VInt 2; Value.VInt 3 ]
+        in
+        check_equal_string "keys" "(collection (2 20) (3 30))" (Value.to_string result) );
+    ( "helpers are applied at their call sites",
+      fun () ->
+        let result =
+          run_text
+            "input rows : collection int\nlet scale n = n * 3\nlet offset n = scale n + 1\nquery q = rows |> map offset |> sum\n"
+            [ Value.VInt 1; Value.VInt 2 ]
+        in
+        check_equal_string "sum" "11" (Value.to_string result) );
+    ( "records and tuples are compared structurally",
+      fun () ->
+        let result =
+          run_text
+            "type pair = { first : int; second : int }\ninput rows : collection pair\nquery q = rows |> filter (fun r -> r = { first = 1; second = 2 }) |> count\n"
+            [ Value.VRecord ("pair", [ ("first", Value.VInt 1); ("second", Value.VInt 2) ]); Value.VRecord ("pair", [ ("first", Value.VInt 2); ("second", Value.VInt 1) ]) ]
+        in
+        check_equal_string "count" "1" (Value.to_string result) );
+    ( "a constant query ignores the input",
+      fun () ->
+        let result = run_text "input rows : collection int\nquery q = 6 * 7\n" [ Value.VInt 1 ] in
+        check_equal_string "constant" "42" (Value.to_string result) );
+    ( "out of range arithmetic follows machine integers",
+      fun () ->
+        let result =
+          run_text "input rows : collection int\nquery q = rows |> sum\n"
+            [ Value.VInt max_int; Value.VInt 1 ]
+        in
+        check_equal_string "wrapped" (string_of_int min_int) (Value.to_string result) );
+  ]