datahike-browser-tests 1.0.0

package/test/datahike/test/attribute_refs/query_not_test.cljc

@@ -0,0 +1,193 @@
+(ns datahike.test.attribute-refs.query-not-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [deftest are]]
+      :clj [clojure.test :as t :refer [deftest are]])
+   [datahike.api :as d]
+   #?(:cljs [datahike.cljs :refer [Throwable]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               shift-entities shift shift-in
+                                               wrap-direct-datoms]]))
+
+(def test-db
+  (d/db-with ref-db
+             (shift-entities ref-e0 [{:db/id 1 :mname "Ivan" :age 10}
+                                     {:db/id 2 :mname "Ivan" :age 20}
+                                     {:db/id 3 :mname "Oleg" :age 10}
+                                     {:db/id 4 :mname "Oleg" :age 20}
+                                     {:db/id 5 :mname "Ivan" :age 10}
+                                     {:db/id 6 :mname "Ivan" :age 20}])))
+
+(deftest test-not
+  (are [q res] (= res
+                  (set (d/q (into '[:find [?e ...] :where] q) test-db)))
+    '[[?e :mname]
+      (not [?e :mname "Ivan"])]
+    (shift #{3 4} ref-e0)
+
+    '[[?e :mname]
+      (not
+       [?e :mname "Ivan"]
+       [?e :age  10])]
+    (shift #{2 3 4 6} ref-e0)
+
+    '[[?e :mname]
+      (not [?e :mname "Ivan"])
+      (not [?e :age 10])]
+    (shift #{4} ref-e0)
+
+    ;; full exclude
+    '[[?e :mname]
+      (not [?e :age])]
+    #{}
+
+    ;; not-intersecting rels
+    '[[?e :mname "Ivan"]
+      (not [?e :mname "Oleg"])]
+    (shift #{1 2 5 6} ref-e0)
+
+    ;; exclude empty set
+    '[[?e :mname]
+      (not [?e :mname "Ivan"]
+           [?e :mname "Oleg"])]
+    (shift #{1 2 3 4 5 6} ref-e0)
+
+    ;; nested excludes
+    '[[?e :mname]
+      (not [?e :mname "Ivan"]
+           (not [?e :age 10]))]
+    (shift #{1 3 4 5} ref-e0)
+
+    ;; extra binding in not
+    '[[?e :mname ?a]
+      (not [?e :age ?f]
+           [?e :age 10])]
+    (shift #{2 4 6} ref-e0)))
+
+(deftest test-not-join
+  (are [q res] (= res
+                  (d/q (into '[:find ?e ?a :where] q)
+                       test-db))
+    '[[?e :mname]
+      [?e :age  ?a]
+      (not-join [?e]
+                [?e :mname "Oleg"]
+                [?e :age ?a])]
+    (shift-in #{[1 10] [2 20] [5 10] [6 20]} [0] ref-e0)
+
+    '[[?e :age  ?a]
+      [?e :age  10]
+      (not-join [?e]
+                [?e :mname "Oleg"]
+                [?e :age  ?a]
+                [?e :age  10])]
+    (shift-in #{[1 10] [5 10]} [0] ref-e0)))
+
+(deftest test-default-source
+  (let [db1 (d/db-with ref-db
+                       (wrap-direct-datoms ref-db ref-e0 :db/add
+                                           [[1 :mname "Ivan"]
+                                            [2 :mname "Oleg"]]))
+        db2 (d/db-with ref-db
+                       (wrap-direct-datoms ref-db ref-e0 :db/add
+                                           [[1 :age 10]
+                                            [2 :age 20]]))]
+    (are [q res] (= res
+                    (set (d/q (into '[:find [?e ...]
+                                      :in   $ $2
+                                      :where]
+                                    q)
+                              db1 db2)))
+      ;; NOT inherits default source
+      '[[?e :mname]
+        (not [?e :mname "Ivan"])]
+      (shift #{2} ref-e0)
+
+      ;; NOT can reference any source
+      '[[?e :mname]
+        (not [$2 ?e :age 10])]
+      (shift #{2} ref-e0)
+
+      ;; NOT can change default source
+      '[[?e :mname]
+        ($2 not [?e :age 10])]
+      (shift #{2} ref-e0)
+
+      ;; even with another default source, it can reference any other source explicitly
+      '[[?e :mname]
+        ($2 not [$ ?e :mname "Ivan"])]
+      (shift #{2} ref-e0)
+
+      ;; nested NOT keeps the default source
+      '[[?e :mname]
+        ($2 not (not [?e :age 10]))]
+      (shift #{1} ref-e0)
+
+      ;; can override nested NOT source
+      '[[?e :mname]
+        ($2 not ($ not [?e :mname "Ivan"]))]
+      (shift #{1} ref-e0))))
+
+(deftest test-impl-edge-cases
+  (are [q res] (= res
+                  (d/q q test-db))
+    ;; const \ empty
+    '[:find ?e
+      :where [?e :mname "Oleg"]
+      [?e :age  10]
+      (not [?e :age 20])]
+    (shift-in #{[3]} [0] ref-e0)
+
+    ;; const \ const
+    '[:find ?e
+      :where [?e :mname "Oleg"]
+      [?e :age  10]
+      (not [?e :age 10])]
+    #{}
+
+    ;; rel \ const
+    '[:find ?e
+      :where [?e :mname "Oleg"]
+      (not [?e :age 10])]
+    (shift-in #{[4]} [0] ref-e0)
+
+    ;; 2 rels \ 2 rels
+    '[:find ?e ?e2
+      :where [?e  :mname "Ivan"]
+      [?e2 :mname "Ivan"]
+      (not [?e :age 10]
+           [?e2 :age 20])]
+    (shift-in #{[2 1] [6 5] [1 1] [2 2] [5 5] [6 6] [2 5] [1 5] [2 6] [6 1] [5 1] [6 2]} [0 1] ref-e0)
+
+    ;; 2 rels \ rel + const
+    '[:find ?e ?e2
+      :where [?e  :mname "Ivan"]
+      [?e2 :mname "Oleg"]
+      (not [?e :age 10]
+           [?e2 :age 20])]
+    (shift-in #{[2 3] [1 3] [2 4] [6 3] [5 3] [6 4]} [0 1] ref-e0)
+
+    ;; 2 rels \ 2 consts
+    '[:find ?e ?e2
+      :where [?e  :mname "Oleg"]
+      [?e2 :mname "Oleg"]
+      (not [?e :age 10]
+           [?e2 :age 20])]
+    (shift-in #{[4 3] [3 3] [4 4]} [0 1] ref-e0)))
+
+(deftest test-insufficient-bindings
+  (are [q msg] (thrown-with-msg? Throwable msg
+                                 (d/q (into '[:find ?e :where] q)
+                                      test-db))
+    '[(not [?e :mname "Ivan"])
+      [?e :mname]]
+    #"Insufficient bindings: none of #\{\?e\} is bound"
+
+    '[[?e :mname]
+      (not-join [?e]
+                (not [1 :age ?a])
+                [?e :age ?a])]
+    #"Insufficient bindings: none of #\{\?a\} is bound"
+
+    '[[?e :mname]
+      (not [?a :mname "Ivan"])]
+    #"Insufficient bindings: none of #\{\?a\} is bound"))

package/test/datahike/test/attribute_refs/query_or_test.cljc

@@ -0,0 +1,137 @@
+(ns datahike.test.attribute-refs.query-or-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest are]]
+      :clj [clojure.test :as t :refer [is deftest are]])
+   #?(:cljs [datahike.cljs :refer [Throwable]])
+   [datahike.api :as d]
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               shift-entities
+                                               wrap-direct-datoms
+                                               shift]]))
+
+(def test-db
+  (d/db-with ref-db
+             (shift-entities ref-e0 [{:db/id 1 :weight 40 :age 10}
+                                     {:db/id 2 :weight 40 :age 20}
+                                     {:db/id 3 :weight 45 :age 10}
+                                     {:db/id 4 :weight 45 :age 20}
+                                     {:db/id 5 :weight 40 :age 10}
+                                     {:db/id 6 :weight 40 :age 20}])))
+
+(deftest test-or
+  (are [q res] (= (into #{} (map vector) res)
+                  (d/q (into '[:find ?e :where] q) test-db))
+
+    ;; intersecting results
+    '[(or [?e :weight 45]
+          [?e :age 10])]
+    (shift #{1 3 4 5} ref-e0)
+
+    ;; one branch empty
+    '[(or [?e :weight 45]
+          [?e :age 30])]
+    (shift #{3 4} ref-e0)
+
+    ;; both empty
+    '[(or [?e :weight 60]
+          [?e :age 30])]
+    #{}
+
+    ;; join with 1 var
+    '[[?e :weight 40]
+      (or [?e :weight 45]
+          [?e :age 10])]
+    (shift #{1 5} ref-e0)
+
+    ;; join with 2 vars
+    '[[?e :age ?a]
+      (or (and [?e :weight 40]
+               [_ :age  ?a])
+          (and [?e :weight 45]
+               [_ :age  ?a]))]
+    (shift #{1 2 3 4 5 6} ref-e0)
+
+    ;; OR introduces vars
+    '[(or (and [?e :weight 40]
+               [_ :age  ?a])
+          (and [?e :weight 45]
+               [_ :age  ?a]))
+      [?e :age ?a]]
+    (shift #{1 2 3 4 5 6} ref-e0)
+
+    ;; OR introduces vars in different order
+    '[(or (and [?e :weight 40]
+               [_  :age  ?a])
+          (and [_  :age  ?a]
+               [?e :weight 45]))
+      [?e :age ?a]]
+    (shift #{1 2 3 4 5 6} ref-e0)))
+
+(deftest test-or-join
+  (are [q res] (= (into #{} (map vector) res)
+                  (d/q (into '[:find ?e :where] q)
+                       test-db))
+    '[(or-join [?e]
+               [?e :weight ?n]
+               (and [?e :age ?a]
+                    [?e :weight ?n]))]
+    (shift #{1 2 3 4 5 6} ref-e0)
+
+    '[[?e  :weight ?a]
+      [?e2 :weight ?a]
+      (or-join [?e]
+               (and [?e  :age ?a]
+                    [?e2 :age ?a]))]
+    (shift #{1 2 3 4 5 6} ref-e0)))
+
+(deftest test-default-source
+  (let [db1 (d/db-with ref-db
+                       (wrap-direct-datoms ref-db ref-e0 :db/add [[1 :weight 40]
+                                                                  [2 :weight 45]]))
+        db2 (d/db-with ref-db
+                       (wrap-direct-datoms ref-db ref-e0 :db/add [[1 :age 10]
+                                                                  [2 :age 20]]))]
+    (are [q res] (= (d/q (into '[:find ?e :in $ $2 :where] q) db1 db2)
+                    (into #{} (map vector) res))
+      ;; OR inherits default source
+      '[[?e :weight]
+        (or [?e :weight 40])]
+      (shift #{1} ref-e0)
+
+      ;; OR can reference any source
+      '[[?e :weight]
+        (or [$2 ?e :age 10])]
+      (shift #{1} ref-e0)
+
+      ;; OR can change default source
+      '[[?e :weight]
+        ($2 or [?e :age 10])]
+      (shift #{1} ref-e0)
+
+      ;; even with another default source, it can reference any other source explicitly
+      '[[?e :weight]
+        ($2 or [$ ?e :weight 40])]
+      (shift #{1} ref-e0)
+
+      ;; nested OR keeps the default source
+      '[[?e :weight]
+        ($2 or (or [?e :age 10]))]
+      (shift #{1} ref-e0)
+
+      ;; can override nested OR source
+      '[[?e :weight]
+        ($2 or ($ or [?e :weight 40]))]
+      (shift #{1} ref-e0))))
+
+(deftest test-errors
+  (is (thrown-with-msg? Throwable #"Join variable not declared inside clauses"
+                        (d/q '[:find ?e
+                               :where (or [?e :weight _]
+                                          [?e :age ?a])]
+                             test-db)))
+
+  (is (thrown-with-msg? Throwable #"Insufficient bindings: #\{\?e\} not bound"
+                        (d/q '[:find ?e
+                               :where (or-join [[?e]]
+                                               [?e :weight 40])]
+                             test-db))))

package/test/datahike/test/attribute_refs/query_pull_test.cljc

@@ -0,0 +1,156 @@
+(ns datahike.test.attribute-refs.query-pull-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing are]]
+      :clj [clojure.test :as t :refer [is deftest testing are]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               shift-entities
+                                               shift-in]]
+   [datahike.api :as d]))
+
+(def test-db (d/db-with ref-db
+                        (shift-entities ref-e0 [{:db/id 1 :name "Petr" :age 44}
+                                                {:db/id 2 :name "Ivan" :age 25}
+                                                {:db/id 3 :name "Oleg" :age 11}])))
+
+(deftest test-basics
+  (are [find res] (= res
+                     (set (d/q {:find find
+                                :where '[[?e :age ?a]
+                                         [(>= ?a 18)]]}
+                               test-db)))
+    '[(pull ?e [:name])]
+    #{[{:name "Ivan"}] [{:name "Petr"}]}
+
+    '[(pull ?e [*])]
+    #{(shift-entities ref-e0 [{:db/id 2 :age 25 :name "Ivan"}])
+      (shift-entities ref-e0 [{:db/id 1 :age 44 :name "Petr"}])}
+
+    '[?e (pull ?e [:name])]
+    (shift-in #{[2 {:name "Ivan"}] [1 {:name "Petr"}]} [0] ref-e0)
+
+    '[?e ?a (pull ?e [:name])]
+    (shift-in #{[2 25 {:name "Ivan"}] [1 44 {:name "Petr"}]} [0] ref-e0)
+
+    '[?e (pull ?e [:name]) ?a]
+    (shift-in #{[2 {:name "Ivan"} 25] [1 {:name "Petr"} 44]} [0] ref-e0)))
+
+(deftest test-var-pattern
+  (are [find pattern res] (= res
+                             (set (d/q {:find find
+                                        :in   '[$ ?pattern]
+                                        :where '[[?e :age ?a]
+                                                 [(>= ?a 18)]]}
+                                       test-db pattern)))
+    '[(pull ?e ?pattern)] [:name]
+    #{[{:name "Ivan"}] [{:name "Petr"}]}
+
+    '[?e ?a ?pattern (pull ?e ?pattern)] [:name]
+    (shift-in #{[2 25 [:name] {:name "Ivan"}] [1 44 [:name] {:name "Petr"}]} [0] ref-e0)))
+
+;; not supported
+#_(deftest test-multi-pattern
+    (is (= (set (d/q '[:find ?e ?p (pull ?e ?p)
+                       :in $ [?p ...]
+                       :where [?e :age ?a]
+                       [>= ?a 18]]
+                     test-db [[:name] [:age]]))
+           #{[2 [:name] {:name "Ivan"}]
+             [2 [:age]  {:age 25}]
+             [1 [:name] {:name "Petr"}]
+             [1 [:age]  {:age 44}]})))
+
+(deftest test-multiple-sources
+  (let [db1 (d/db-with ref-db (shift-entities ref-e0 [{:db/id 1 :name "Ivan" :age 25}]))
+        db2 (d/db-with ref-db (shift-entities ref-e0 [{:db/id 1 :name "Petr" :age 25}]))]
+    (is (= (shift-in #{[1 {:name "Ivan"}]} [0] ref-e0)
+           (set (d/q '[:find ?e (pull $1 ?e [:name])
+                       :in $1 $2
+                       :where [$1 ?e :age 25]]
+                     db1 db2))))
+
+    (is (=  (shift-in #{[1 {:name "Petr"}]} [0] ref-e0)
+            (set (d/q '[:find ?e (pull $2 ?e [:name])
+                        :in $1 $2
+                        :where [$2 ?e :age 25]]
+                      db1 db2))))
+
+    (testing "$ is default source"
+      (is (= (shift-in #{[1 {:name "Petr"}]} [0] ref-e0)
+             (set (d/q '[:find ?e (pull ?e [:name])
+                         :in $1 $
+                         :where [$ ?e :age 25]]
+                       db1 db2)))))))
+
+(deftest test-find-spec
+  (is (= {:name "Ivan"}
+         (d/q '[:find (pull ?e [:name]) .
+                :where [?e :age 25]]
+              test-db)))
+
+  (is (= #{{:name "Ivan"} {:name "Petr"} {:name "Oleg"}}
+         (set (d/q '[:find [(pull ?e [:name]) ...]
+                     :where [?e :age ?a]]
+                   test-db))))
+
+  (is (= [(+ ref-e0 2) {:name "Ivan"}]
+         (d/q '[:find [?e (pull ?e [:name])]
+                :where [?e :age 25]]
+              test-db))))
+
+(deftest test-find-spec-input
+  (let [pattern '[*]]
+    (is (= (d/pull test-db pattern 1)
+           (d/q '[:find (pull ?e ?p) .
+                  :in $ ?p
+                  :where [(ground 1) ?e]]
+                test-db pattern)))))
+
+(deftest test-aggregates
+  (let [db (d/db-with ref-db
+                      (shift-entities ref-e0 [{:db/id 1 :name "Petr" :value [10 20 30 40]}
+                                              {:db/id 2 :name "Ivan" :value [14 16]}
+                                              {:db/id 3 :name "Oleg" :value 1}]))]
+    (is (= (shift-in #{[1 {:name "Petr"} 10 40]
+                       [2 {:name "Ivan"} 14 16]
+                       [3 {:name "Oleg"} 1 1]} [0] ref-e0)
+           (set (d/q '[:find ?e (pull ?e [:name]) (min ?v) (max ?v)
+                       :where [?e :value ?v]]
+                     db))))))
+
+(deftest test-lookup-refs
+  (let [db (d/db-with ref-db
+                      (shift-entities ref-e0 [{:db/id 1 :name "Petr" :age 44}
+                                              {:db/id 2 :name "Ivan" :age 25}
+                                              {:db/id 3 :name "Oleg" :age 11}]))]
+    (is (=  #{[[:name "Petr"] 44 {:db/id (+ ref-e0 1) :name "Petr"}]
+              [[:name "Ivan"] 25 {:db/id (+ ref-e0 2) :name "Ivan"}]}
+            (set (d/q '[:find ?ref ?a (pull ?ref [:db/id :name])
+                        :in   $ [?ref ...]
+                        :where [?ref :age ?a]
+                        [(>= ?a 18)]]
+                      db [[:name "Ivan"] [:name "Oleg"] [:name "Petr"]]))))))
+
+(deftest test-pull-attribute
+  (testing "Pull an attribute"
+    (let [db (d/db-with ref-db [{:db/ident :attribute-to-use
+                                 :db/cardinality :db.cardinality/one
+                                 :db/valueType :db.type/keyword}])
+          result (d/q '[:find (pull ?attr [*])
+                        :in $ ?attr-name
+                        :where
+                        [?attr :db/ident ?attr-name]]
+                      db :attribute-to-use)
+          [[x]] result
+          ids [(:db/id x)
+               (-> x :db/valueType :db/id)
+               (-> x :db/cardinality :db/id)]]
+      (is (= 1 (count result)))
+      (is (= 1 (count (first result))))
+      (is (= #{:db/id :db/ident :db/valueType :db/cardinality} (set (keys x))))
+      (is (number? (:db/id x)))
+      (is (= :attribute-to-use (:db/ident x)))
+      (is (= :db.type/keyword (-> x :db/valueType :db/ident)))
+      (is (= :db.cardinality/one (-> x :db/cardinality :db/ident)))
+      (is (every? number? ids))
+      (is (= (count (set ids))
+             (count ids))))))

package/test/datahike/test/attribute_refs/query_rules_test.cljc

@@ -0,0 +1,176 @@
+(ns datahike.test.attribute_refs.query-rules-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj [clojure.test :as t :refer [is deftest testing]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               wrap-direct-datoms
+                                               wrap-ref-datoms
+                                               shift-in]]
+   [datahike.api :as d]))
+
+(deftest test-rules
+  (let [datoms [[1 :follow 2]
+                [2 :follow 3]
+                [2 :follow 4]
+                [3 :follow 4]
+                [4 :follow 6]
+                [5 :follow 3]]
+        db (d/db-with ref-db (wrap-ref-datoms ref-db ref-e0 :db/add datoms))
+        all-pairs (shift-in #{[1 2] [2 3] [2 4] [3 4] [4 6] [5 3]} [0 1] ref-e0)
+        all-pairs-reversed (shift-in #{[2 1] [3 2] [4 2] [4 3] [6 4] [3 5]} [0 1] ref-e0)]
+    (is (= all-pairs
+           (d/q '[:find  ?e1 ?e2
+                  :in    $ %
+                  :where (follow ?e1 ?e2)]
+                db
+                '[[(follow ?x ?y)
+                   [?x :follow ?y]]])))
+
+    (testing "Joining regular clauses with rule"
+      (is (= (set (filter (fn [[_ x]] (and (even? x) ((set (map first all-pairs-reversed)) x)))
+                          all-pairs-reversed))
+             (d/q '[:find ?y ?x
+                    :in $ %
+                    :where [_ _ ?x]
+                    (rule ?x ?y)
+                    [(even? ?x)]]
+                  db
+                  '[[(rule ?a ?b)
+                     [?a :follow ?b]]]))))
+
+    (testing "Rule context is isolated from outer context"
+      (is (= (shift-in #{[2] [3] [4] [6]} [0] ref-e0)
+             (d/q '[:find ?x
+                    :in $ %
+                    :where [?e _ _]
+                    (rule ?x)]
+                  db
+                  '[[(rule ?e)
+                     [_ :follow ?e]]]))))
+
+    (testing "Rule with branches"
+      (is (= (shift-in #{[2] [3] [4]} [0] ref-e0)
+             (d/q '[:find  ?e2
+                    :in    $ ?e1 %
+                    :where (follow ?e1 ?e2)]
+                  db
+                  (+ 1 ref-e0)
+                  '[[(follow ?e2 ?e1)
+                     [?e2 :follow ?e1]]
+                    [(follow ?e2 ?e1)
+                     [?e2 :follow ?t]
+                     [?t  :follow ?e1]]]))))
+
+    (testing "Recursive rules"
+      (is (= (shift-in #{[2] [3] [4] [6]} [0] ref-e0)
+             (d/q '[:find  ?e2
+                    :in    $ ?e1 %
+                    :where (follow ?e1 ?e2)]
+                  db
+                  (+ 1 ref-e0)
+                  '[[(follow ?e1 ?e2)
+                     [?e1 :follow ?e2]]
+                    [(follow ?e1 ?e2)
+                     [?e1 :follow ?t]
+                     (follow ?t ?e2)]])))
+
+      (is (= (shift-in #{[1 2] [2 3] [2 1] [3 2]} [0 1] ref-e0)
+             (d/q '[:find ?e1 ?e2
+                    :in $ %
+                    :where (follow ?e1 ?e2)]
+                  (d/db-with ref-db (wrap-ref-datoms ref-db ref-e0 :db/add
+                                                     [[1 :follow 2] [2 :follow 3]]))
+                  '[[(follow ?e1 ?e2)
+                     [?e1 :follow ?e2]]
+                    [(follow ?e1 ?e2)
+                     (follow ?e2 ?e1)]])))
+
+      (is (= (shift-in #{[1 2] [2 3] [3 1] [2 1] [3 2] [1 3]} [0 1] ref-e0)
+             (d/q '[:find ?e1 ?e2
+                    :in $ %
+                    :where (follow ?e1 ?e2)]
+                  (d/db-with ref-db (wrap-ref-datoms ref-db ref-e0 :db/add
+                                                     [[1 :follow 2] [2 :follow 3] [3 :follow 1]]))
+                  '[[(follow ?e1 ?e2)
+                     [?e1 :follow ?e2]]
+                    [(follow ?e1 ?e2)
+                     (follow ?e2 ?e1)]]))))
+
+    (testing "Mutually recursive rules"
+      (let [datoms [[0 :f1 1]
+                    [1 :f2 2]
+                    [2 :f1 3]
+                    [3 :f2 4]
+                    [4 :f1 5]
+                    [5 :f2 6]]
+            db2 (d/db-with ref-db (wrap-ref-datoms ref-db ref-e0 :db/add datoms))]
+        (is (= (shift-in #{[0 1] [0 3] [0 5]
+                           [1 3] [1 5]
+                           [2 3] [2 5]
+                           [3 5]
+                           [4 5]} [0 1] ref-e0)
+               (d/q '[:find  ?e1 ?e2
+                      :in    $ %
+                      :where (f1 ?e1 ?e2)]
+                    db2
+                    '[[(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)]])))))
+
+    (testing "Passing ins to rule"
+      (is (= (set (filter (fn [[x y]] (and (even? x) (even? y)))
+                          all-pairs))
+             (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?))))
+
+    (testing "Using built-ins inside rule"
+      (is (= (set (filter (fn [[x y]] (and (even? x) (even? y)))
+                          all-pairs))
+             (d/q '[:find ?x ?y
+                    :in $ %
+                    :where (match ?x ?y)]
+                  db
+                  '[[(match ?e ?e2)
+                     [?e :follow ?e2]
+                     [(even? ?e)]
+                     [(even? ?e2)]]]))))
+    (testing "Calling rule twice (#44)"
+      (d/q '[:find ?p
+             :in $ % ?fn
+             :where (rule ?p ?fn :a)
+             (rule ?p ?fn :b)]
+           (d/db-with ref-db (wrap-direct-datoms ref-db ref-e0 :db/add [[1 :attr :a]]))
+           '[[(rule ?p ?fn ?x)
+              [?p :attr ?x]
+              [(?fn ?x)]]]
+           (constantly true)))))
+
+(deftest test-false-arguments
+  (let [db    (d/db-with ref-db
+                         (wrap-direct-datoms ref-db ref-e0 :db/add [[1 :huh? true]
+                                                                    [2 :huh? false]]))
+        rules '[[(is ?id ?val)
+                 [?id :huh? ?val]]]]
+    (is (= (shift-in #{[1]} [0] ref-e0)
+           (d/q '[:find ?id :in $ %
+                  :where (is ?id true)]
+                db rules)))
+    (is (= (shift-in #{[2]} [0] ref-e0)
+           (d/q '[:find ?id :in $ %
+                  :where (is ?id false)]
+                db rules)))))