Indexes on vectors return surprising results

まず、2つの再現用スニペットを実行し、インデックス付きの :path 属性に対する d/datoms :avet ルックアップを追跡します。追加の :children datom がある場合とない場合で、ベクター、リスト、シーケンスの入力を比較します；完了の条件は、ルックアップが一貫して動作し、意図したインデックス付きの値にのみ一致することです。

I'm seeing some odd behavior with indexed vectors. I thought this might have been introduced in 1.6.4, but it was also happening in 1.6.3. Given

(let [db (-> (d/empty-db {:path {:db/index true}})
             (d/db-with [{:path [1 2]}
                         {:path [1 2 3]}]))]
  (for [v [;; variations on 1, 2
           [1 2]
           (list 1 2)
           (butlast [1 2 3])

           ;; variations on 1, 2, 3
           [1 2 3]
           (list 1 2 3)
           (butlast [1 2 3 4])]]
    [v
     (->> (d/datoms db :avet :path v)
          (mapv :e))]))

I'd expect this to only find entity ids for the first and fourth values of v, i.e. for the vectors, not the lists or sequences. However, this is what is returned.

;; => ([[1 2] [1]]
;;     [(1 2) [1]]
;;     [(1 2) []]
;;     [[1 2 3] [2]]
;;     [(1 2 3) []]
;;     [(1 2 3) [2]])

It's particularly odd that first list, (list 1 2) returns an entity id but (list 1 2 3) doesn't. And contrarily that the first sequence (butlast [1 2 3]) doesn't return an entity id but (butlast [1 2 3 4]) does.

As I was playing with this I also ran across another odd variation. The presence of other datoms seems to affect the result.

(let [db (-> (d/empty-db {:path {:db/index true}
                          ;; this attribute is new
                          :children {:db/valueType :db.type/ref
                                     :db/cardinality :db.cardinality/many}})
             (d/db-with [{:db/id "a"
                          :path [1 2]}
                         {:db/id "b"
                          :path [1 2 3]}
                         ;; this datom is new
                         [:db/add "a" :children "b"]]))]
  (for [v [;; variations on 1, 2
           [1 2]
           (list 1 2)
           (butlast [1 2 3])

           ;; variations on 1, 2, 3
           [1 2 3]
           (list 1 2 3)
           (butlast [1 2 3 4])]]
    [v
     (->> (d/datoms db :avet :path v)
          (mapv :e))]))

;; => ([[1 2] [1]]
;;     [(1 2) [1]]
;;     this result has changed
;;     [(1 2) [1 2]]
;;     [[1 2 3] [2]]
;;     [(1 2 3) []]
;;     [(1 2 3) [2]])

Here the result is almost the same, except that whereas before when v was (list 1 2), d/datoms returned nothing. Now, with the other datom, it returns both entity ids. Very odd!

The easiest fix is, on the calling side, to be careful to pass vectors not sequences. That's what we'll do in our project, but I wanted to report the issue anyway.