datahike-browser-tests 1.0.0

package/test/datahike/test/query_rules_test.cljc

@@ -0,0 +1,248 @@
+(ns datahike.test.query-rules-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer        [is deftest testing]])
+   [datahike.api :as d]
+   [datahike.db :as db]))
+
+#?(:cljs (def Throwable js/Error))
+
+(deftest test-rules
+  (let [db [[5 :follow 3]
+            [1 :follow 2] [2 :follow 3] [3 :follow 4] [4 :follow 6]
+            [2         :follow           4]]]
+    (is (= (d/q '[:find  ?e1 ?e2
+                  :in    $ %
+                  :where (follow ?e1 ?e2)]
+                db
+                '[[(follow ?x ?y)
+                   [?x :follow ?y]]])
+           #{[1 2] [2 3] [3 4] [2 4] [5 3] [4 6]}))
+
+    (testing "Joining regular clauses with rule"
+      (is (= (d/q '[:find ?y ?x
+                    :in $ %
+                    :where [_ _ ?x]
+                    (rule ?x ?y)
+                    [(even? ?x)]]
+                  db
+                  '[[(rule ?a ?b)
+                     [?a :follow ?b]]])
+             #{[3 2] [6 4] [4 2]})))
+
+    (testing "Rule context is isolated from outer context"
+      (is (= (d/q '[:find ?x
+                    :in $ %
+                    :where [?e _ _]
+                    (rule ?x)]
+                  db
+                  '[[(rule ?e)
+                     [_ ?e _]]])
+             #{[:follow]})))
+
+    (testing "Rule with branches"
+      (is (= (d/q '[:find  ?e2
+                    :in    $ ?e1 %
+                    :where (follow ?e1 ?e2)]
+                  db
+                  1
+                  '[[(follow ?e2 ?e1)
+                     [?e2 :follow ?e1]]
+                    [(follow ?e2 ?e1)
+                     [?e2 :follow ?t]
+                     [?t  :follow ?e1]]])
+             #{[2] [3] [4]})))
+
+    (testing "Recursive rules"
+      (is (= (d/q '[:find  ?e2
+                    :in    $ ?e1 %
+                    :where (follow ?e1 ?e2)]
+                  db
+                  1
+                  '[[(follow ?e1 ?e2)
+                     [?e1 :follow ?e2]]
+                    [(follow ?e1 ?e2)
+                     [?e1 :follow ?t]
+                     (follow ?t ?e2)]])
+             #{[2] [3] [4] [6]}))
+
+      (is (= (d/q '[:find ?e1 ?e2
+                    :in $ %
+                    :where (follow ?e1 ?e2)]
+                  [[1 :follow 2] [2 :follow 3]]
+                  '[[(follow ?e1 ?e2)
+                     [?e1 :follow ?e2]]
+                    [(follow ?e1 ?e2)
+                     (follow ?e2 ?e1)]])
+             #{[1 2] [2 3] [2 1] [3 2]}))
+
+      (is (= (d/q '[:find ?e1 ?e2
+                    :in $ %
+                    :where (follow ?e1 ?e2)]
+                  [[1 :follow 2] [2 :follow 3] [3 :follow 1]]
+                  '[[(follow ?e1 ?e2)
+                     [?e1 :follow ?e2]]
+                    [(follow ?e1 ?e2)
+                     (follow ?e2 ?e1)]])
+             #{[1 2] [2 3] [3 1] [2 1] [3 2] [1 3]})))
+
+    (testing "Mutually recursive rules"
+      (is (= (d/q '[:find  ?e1 ?e2
+                    :in    $ %
+                    :where (f1 ?e1 ?e2)]
+                  [[0 :f1 1]
+                   [1 :f2 2]
+                   [2 :f1 3]
+                   [3 :f2 4]
+                   [4 :f1 5]
+                   [5 :f2 6]]
+                  '[[(f1 ?e1 ?e2)
+                     [?e1 :f1 ?e2]]
+                    [(f1 ?e1 ?e2)
+                     [?t :f1 ?e2]
+                     (f2 ?e1 ?t)]
+                    [(f2 ?e1 ?e2)
+                     [?e1 :f2 ?e2]]
+                    [(f2 ?e1 ?e2)
+                     [?t :f2 ?e2]
+                     (f1 ?e1 ?t)]])
+             #{[0 1] [0 3] [0 5]
+               [1 3] [1 5]
+               [2 3] [2 5]
+               [3 5]
+               [4 5]})))
+
+    (testing "Passing ins to rule"
+      (is (= (d/q '[:find ?x ?y
+                    :in $ % ?even
+                    :where
+                    (match ?even ?x ?y)]
+                  db
+                  '[[(match ?pred ?e ?e2)
+                     [?e :follow ?e2]
+                     [(?pred ?e)]
+                     [(?pred ?e2)]]]
+                  even?)
+             #{[4 6] [2 4]})))
+
+    (testing "Using built-ins inside rule"
+      (is (= (d/q '[:find ?x ?y
+                    :in $ %
+                    :where (match ?x ?y)]
+                  db
+                  '[[(match ?e ?e2)
+                     [?e :follow ?e2]
+                     [(even? ?e)]
+                     [(even? ?e2)]]])
+             #{[4 6] [2 4]})))
+    (testing "Calling rule twice (#44)"
+      (d/q '[:find ?p
+             :in $ % ?fn
+             :where (rule ?p ?fn "a")
+             (rule ?p ?fn "b")]
+           [[1 :attr "a"]]
+           '[[(rule ?p ?fn ?x)
+              [?p :attr ?x]
+              [(?fn ?x)]]]
+           (constantly true))))
+
+  (testing "Specifying db to rule"
+    (is (= (d/q '[:find ?n
+                  :in   $sexes $ages %
+                  :where ($sexes male ?n)
+                  ($ages adult ?n)]
+                [["Ivan" :male] ["Darya" :female] ["Oleg" :male] ["Igor" :male]]
+                [["Ivan" 15] ["Oleg" 66] ["Darya" 32]]
+                '[[(male ?x)
+                   [?x :male]]
+                  [(adult ?y)
+                   [?y ?a]
+                   [(>= ?a 18)]]])
+           #{["Oleg"]}))))
+
+;; https://github.com/tonsky/datahike/issues/218
+
+(deftest test-false-arguments
+  (let [db    (d/db-with (db/empty-db)
+                         [[:db/add 1 :attr true]
+                          [:db/add 2 :attr false]])
+        rules '[[(is ?id ?val)
+                 [?id :attr ?val]]]]
+    (is (= (d/q '[:find ?id :in $ %
+                  :where (is ?id true)]
+                db rules)
+           #{[1]}))
+    (is (= (d/q '[:find ?id :in $ %
+                  :where (is ?id false)] db rules)
+           #{[2]}))))
+
+(deftest test-rule-arguments
+  (let [cfg {:store {:backend :memory
+                     :id #uuid "a0000000-0000-0000-0000-00000000000a"}
+             :name "rule-test"
+             :keep-history? true
+             :schema-flexibility :write
+             :attribute-refs? true}
+        schema [{:db/ident       :name
+                 :db/cardinality :db.cardinality/one
+                 :db/index       true
+                 :db/unique      :db.unique/identity
+                 :db/valueType   :db.type/string}
+                {:db/ident       :parents
+                 :db/cardinality :db.cardinality/many
+                 :db/valueType   :db.type/ref}
+                {:db/ident       :age
+                 :db/cardinality :db.cardinality/one
+                 :db/valueType   :db.type/long}]
+        rules '[[(parent-info ?child ?name ?age)
+                 [?child :parents ?p]
+                 [(ground ["Alice" "Bob"]) [?name ...]]
+                 [?p :name ?name]
+                 [?p :age ?age]]]
+        _ (d/delete-database cfg)
+        _ (d/create-database cfg)
+        conn (d/connect cfg)]
+
+    (d/transact conn {:tx-data schema})
+    (d/transact conn {:tx-data [{:name "Alice"
+                                 :age  25}
+                                {:name "Bob"
+                                 :age 30}]})
+    (d/transact conn {:tx-data [{:name    "Charlie"
+                                 :age     5
+                                 :parents [[:name "Alice"]
+                                           [:name "Bob"]]}]})
+
+    (is (= #{[25]}
+           (d/q {:query '{:find [?age]
+                          :in [$ ?n ?pn %]
+                          :where
+                          [[?child :name ?n]
+                           (parent-info ?child ?pn ?age)]}
+                 :args [@conn "Charlie" "Alice" rules]})))
+
+    (is (= #{[25]}
+           (d/q {:query '{:find [?age]
+                          :in [$ ?n [?pn ...] %]
+                          :where
+                          [[?child :name ?n]
+                           (parent-info ?child ?pn ?age)]}
+                 :args [@conn "Charlie" ["Alice"] rules]})))
+
+    (is (= #{[25]}
+           (d/q {:query '{:find [?age]
+                          :in [$ ?n %]
+                          :where
+                          [[?child :name ?n]
+                           (parent-info ?child "Alice" ?age)]}
+                 :args [@conn "Charlie" rules]})))
+
+    (is (thrown-with-msg? Throwable
+                          #"Bad format for value in pattern, must be a scalar, nil or a vector of two elements."
+                          (d/q {:query '{:find [?age]
+                                         :in [$ ?n %]
+                                         :where
+                                         [[?child :name ?n]
+                                          (parent-info ?child ["Alice"] ?age)]}
+                                :args [@conn "Charlie" rules]})))
+    (d/release conn)))

package/test/datahike/test/query_stats_test.cljc

@@ -0,0 +1,218 @@
+(ns datahike.test.query-stats-test
+  (:require #?(:cljs [cljs.test :as t :refer-macros [is deftest use-fixtures]]
+               :clj [clojure.test :as t :refer [is deftest use-fixtures]])
+            [clojure.string :as str]
+            [clojure.walk :as cw]
+            [datahike.api :as d]
+            [datahike.query :refer [query-stats]]
+            [datahike.test.utils :refer [with-db]]))
+
+(def config {:store {:backend :memory :id #uuid "00190000-0000-0000-0000-000000000019"}})
+
+(def test-schema [{:db/ident :name
+                   :db/valueType :db.type/string
+                   :db/cardinality :db.cardinality/one}
+                  {:db/ident :age
+                   :db/valueType :db.type/long
+                   :db/cardinality :db.cardinality/one}])
+
+(def test-data [{:db/id 1 :name "Ivan" :age 10}
+                {:db/id 2 :name "Ivan" :age 20}
+                {:db/id 3 :name "Oleg" :age 30}
+                {:db/id 4 :name "Oleg" :age 40}
+                {:db/id 5 :name "Ivan" :age 50}
+                {:db/id 6 :name "Michal" :age 60}])
+
+(use-fixtures :once (partial with-db config (into test-schema test-data)))
+
+(defn unify-stats [stats]
+  (cw/postwalk
+   #(cond-> %
+      (and (map? %) (contains? % :t))                  (assoc :t :measurement)
+      (and (symbol? %) (re-find #"__auto__" (name %))) (-> name (str/replace #"__auto__\d*" "_tmp") symbol))
+   stats))
+
+(deftest test-not
+  (is (= {:consts {}
+          :query  '{:find  [[?a ...]]
+                    :where [[?e :age ?a]
+                            (not [?e :age 60])]}
+          :ret    [10 20 40 30 50]
+          :rules  {}
+          :stats  [{:clause '[?e :age ?a]
+                    :rels   [{:bound #{'?a '?e} :rows  6}]
+                    :t      :measurement
+                    :type   :lookup}
+                   {:branches [{:clause '[?e :age 60]
+                                :rels   [{:bound #{'?a '?e} :rows 1}]
+                                :t      :measurement
+                                :type   :lookup}]
+                    :clause   '(not [?e :age 60])
+                    :rels     [{:bound #{'?a '?e} :rows 5}]
+                    :t        :measurement
+                    :type     :not}]}
+         (unify-stats (query-stats '[:find [?a ...] :where
+                                     [?e :age ?a]
+                                     (not [?e :age 60])]
+                                   @(d/connect config))))))
+
+(deftest test-not-join
+  (is (= {:consts {}
+          :query  '{:find  [?a]
+                    :where [[?e :name]
+                            [?e :age ?a]
+                            (not-join [?e]
+                                      [?e :name "Oleg"]
+                                      [?e :age ?a])]}
+          :ret    #{[10] [20] [50] [60]}
+          :rules  {}
+          :stats  [{:clause '[?e :name]
+                    :rels   [{:bound #{'?e} :rows  6}]
+                    :t      :measurement
+                    :type   :lookup}
+                   {:clause '[?e :age ?a]
+                    :rels   [{:bound #{'?a '?e} :rows  6}]
+                    :t      :measurement
+                    :type   :lookup}
+                   {:branches [{:clause '[?e :name "Oleg"]
+                                :rels   [{:bound #{'?e} :rows  2}]
+                                :t      :measurement
+                                :type   :lookup}
+                               {:clause '[?e :age ?a]
+                                :rels   [{:bound #{'?a '?e} :rows  2}]
+                                :t      :measurement
+                                :type   :lookup}]
+                    :clause   '(not-join [?e]
+                                         [?e :name "Oleg"]
+                                         [?e :age ?a])
+                    :rels     [{:bound #{'?a '?e} :rows  4}]
+                    :t        :measurement
+                    :type     :not}]}
+         (unify-stats (query-stats '[:find ?a :where
+                                     [?e :name]
+                                     [?e :age ?a]
+                                     (not-join [?e]
+                                               [?e :name "Oleg"]
+                                               [?e :age ?a])]
+                                   @(d/connect config))))))
+
+(deftest test-or
+  (is (= {:consts {}
+          :query  '{:find  [?a]
+                    :where [[?e :age ?a]
+                            (or [?e :name "Ivan"]
+                                [?e :name "Oleg"])]}
+          :ret    #{[10] [20] [30] [40] [50]}
+          :rules  {}
+          :stats  [{:clause '[?e :age ?a]
+                    :rels   [{:bound #{'?a '?e}
+                              :rows  6}]
+                    :t      :measurement
+                    :type   :lookup}
+                   {:branches [[{:clause '[?e :name "Ivan"]
+                                 :rels   [{:bound #{'?a '?e} :rows  3}]
+                                 :t      :measurement
+                                 :type   :lookup}]
+                               [{:clause '[?e :name "Oleg"]
+                                 :rels   [{:bound #{'?a '?e} :rows  2}]
+                                 :t      :measurement
+                                 :type   :lookup}]]
+                    :clause   '(or [?e :name "Ivan"]
+                                   [?e :name "Oleg"])
+                    :rels     [{:bound #{'?a '?e} :rows  5}]
+                    :t        :measurement
+                    :type     :or}]}
+         (unify-stats (query-stats '[:find ?a :where
+                                     [?e :age ?a]
+                                     (or [?e :name "Ivan"]
+                                         [?e :name "Oleg"])]
+                                   @(d/connect config))))))
+
+(deftest test-rules
+  (let [db [[1 :follow 2]
+            [2 :follow 3]
+            [2 :follow 4]
+            [3 :follow 4]
+            [4 :follow 6]
+            [5 :follow 3]]]
+    (is (= {:consts {},
+            :query '{:find [?y ?x], :in [$ %], :where [[_ _ ?x] (rule ?x ?y) [(even? ?x)]]},
+            :ret #{[3 2] [4 2] [6 4]},
+            :rules {'rule '[[(rule ?a ?b) [?a :follow ?b]]]},
+            :stats [{:clause '[_ _ ?x], :rels [{:bound #{'?x}, :rows 6}], :t :measurement, :type :lookup}
+                    {:branches [{:branches [],
+                                 :clause '(rule ?x ?y),
+                                 :clauses (),
+                                 :rels [{:bound #{'?x}, :rows 6}],
+                                 :t :measurement,
+                                 :type :solve}
+                                {:branches [{:clause '[?x :follow ?y],
+                                             :rels [{:bound #{'?x '?y}, :rows 6}],
+                                             :t :measurement,
+                                             :type :lookup}],
+                                 :clause '([?x :follow ?y]),
+                                 :clauses '([?x :follow ?y]),
+                                 :rels [{:bound #{'?x '?y}, :rows 6}],
+                                 :t :measurement,
+                                 :type :solve}],
+                     :clause '(rule ?x ?y),
+                     :rels [{:bound #{'?x '?y}, :rows 10}],
+                     :t :measurement,
+                     :type :rule}
+                    {:clause '[(even? ?x)], :rels [{:bound #{'?x '?y}, :rows 6}], :t :measurement}]}
+           (unify-stats (query-stats '[:find ?y ?x
+                                       :in $ %
+                                       :where [_ _ ?x]
+                                       (rule ?x ?y)
+                                       [(even? ?x)]]
+                                     db
+                                     '[[(rule ?a ?b)
+                                        [?a :follow ?b]]]))))
+
+    (is (= {:consts '{?e1 1},
+            :query {:find '[?e2], :in '[$ ?e1 %], :where '[(follow ?e1 ?e2)]},
+            :ret #{[2] [3] [4]},
+            :rules {'follow '[[(follow ?e2 ?e1) [?e2 :follow ?e1]]
+                              [(follow ?e2 ?e1) [?e2 :follow ?t] [?t :follow ?e1]]]},
+            :stats [{:branches [{:branches [],
+                                 :clause '(follow ?e1 ?e2),
+                                 :clauses (),
+                                 :rels [],
+                                 :t :measurement,
+                                 :type :solve}
+                                {:branches [{:clause '[?e1 :follow ?e2],
+                                             :rels [{:bound #{'?e1 '?e2}, :rows 1}],
+                                             :t :measurement,
+                                             :type :lookup}],
+                                 :clause '([?e1 :follow ?e2]),
+                                 :clauses '([?e1 :follow ?e2]),
+                                 :rels [{:bound #{'?e1 '?e2}, :rows 1}],
+                                 :t :measurement,
+                                 :type :solve}
+                                {:branches '[{:clause [?e1 :follow ?t_tmp],
+                                              :rels [{:bound #{?e1 ?t_tmp}, :rows 1}],
+                                              :t :measurement,
+                                              :type :lookup}
+                                             {:clause [?t_tmp :follow ?e2],
+                                              :rels [{:bound #{?e1 ?e2 ?t_tmp}, :rows 2}],
+                                              :t :measurement,
+                                              :type :lookup}],
+                                 :clause '([?e1 :follow ?t_tmp] [?t_tmp :follow ?e2]),
+                                 :clauses '([?e1 :follow ?t_tmp] [?t_tmp :follow ?e2]),
+                                 :rels [{:bound #{'?e1 '?e2 '?t_tmp}, :rows 2}],
+                                 :t :measurement,
+                                 :type :solve}],
+                     :clause '(follow ?e1 ?e2),
+                     :rels [{:bound #{'?e1 '?e2}, :rows 3}],
+                     :t :measurement,
+                     :type :rule}]}
+           (unify-stats (query-stats '[:find  ?e2
+                                       :in    $ ?e1 %
+                                       :where (follow ?e1 ?e2)]
+                                     db
+                                     1
+                                     '[[(follow ?e2 ?e1)
+                                        [?e2 :follow ?e1]]
+                                       [(follow ?e2 ?e1)
+                                        [?e2 :follow ?t]
+                                        [?t  :follow ?e1]]]))))))