3

我正在使用 Datascript 查询具有给定名称的 2 个节点的最后一个共同祖先的树结构，这就是我到目前为止所得到的，但它真的很慢 - 知道为什么（或者有更好的方法）吗？

(defn lca
  "Last common ancestor"
  [db name1 name2]
  (d/q '[
          :find [(pull ?anc [:db/id :name]) ...]
          :in    $ % ?name1 ?name2
          :where
            (?node1 :name ?name1)
            (?node2 :name ?name2)
            (anc ?anc1 ?node1)
            (anc ?anc2 ?node2)
            [(not= ?anc1 ?anc2)]
            (parent ?anc ?anc1)
            (parent ?anc ?anc2)
          ]
          @db
          '[
            [ (parent ?par ?child)
              (?par :children ?child)]
            [ (anc ?par ?child)
              (?par :children ?child)]
            [ (anc ?anc ?child)
              (?par :children ?child)
              (anc ?anc ?par)]
            ]
          name1
          name2))

我最初打算用来not排除所有比最后一个常见的祖先更高的祖先，但 Datascript 目前不支持not因此两个父子句。

架构是：

:children {:db/valueType :db.type/ref 
           :db/cardinality :db.cardinality/many 
           :db/index true}
:name {:db/index true}
4

1 回答 1

5

好吧，递归规则并不是 DataScript 中最快的东西。因此，您可以通过将parent规则直接内联到查询代码中来加快查询速度。

另一件事是查询不是最快的，DataScript 也是如此。解析查询、分配中间集合、迭代它们、管理变量等花费了相当多的时间。在两种情况下，您可以更喜欢查询而不是手动数据库/索引访问：

  1. 查询比您自己编写的工作速度更快（例如，在处理大型关系时，查询将使用哈希连接，手动编写非常乏味的事情）
  2. 查询以比命令式算法更简单的方式表达您的问题

在您的情况下，这些都不正确（您并没有真正处理关系，而是线性地走图）。此外，还有一个错误：如果 node1 和 node2 有共同的直接父级，您的查询将不起作用。

我建议通过直接访问实体来做同样的事情。实体只是索引查找，没有任何与查询相关的开销，因此在这种简单的情况下，它们应该工作得更快。

像这样的东西就足够了：

(defn parent [node]
  (first (:_children node)))


(defn ancestors [node]
  (->> node
       (iterate parent)
       (take-while some?)
       reverse))


(defn last-common-ancestor [db name1 name2]
  (let [node1 (d/entity db [:name name1])
        node2 (d/entity db [:name name2])]
         ;; zipping ancestor chains together
    (->> (map vector (ancestors node1) (ancestors node2))
         ;; selecting common prefix
         (take-while (fn [[ac1 ac2]] (= ac1 ac2)))
         ;; last item in common prefix is what you looking for
         (last))))
于 2016-08-10T16:06:05.357 回答