Support extra protocols required for editscript diff-ing

Author: codeboost

src/xitdb/array_list.clj

@@ -76,10 +76,21 @@
       2 (.invoke this (first args) (second args))
       (throw (IllegalArgumentException. "Wrong number of args passed to XITDBArrayList"))))
 
+  clojure.lang.IReduce
+  (reduce [this f]
+    (let [s (seq this)]
+      (if s
+        (reduce f (first s) (rest s))
+        (f))))
+
   clojure.lang.IReduceInit
   (reduce [this f init]
     (reduce f init (array-seq ral)))
 
+  clojure.core.protocols/IKVReduce
+  (kv-reduce [this f init]
+    (util/array-kv-reduce ral #(common/-read-from-cursor %) f init))
+
   java.util.Collection
   (^objects toArray [this]
     (to-array (into [] this)))
@@ -185,6 +196,10 @@
   (seq [this]
     (array-seq wal))
 
+  clojure.core.protocols/IKVReduce
+  (kv-reduce [this f init]
+    (util/array-kv-reduce wal #(common/-read-from-cursor %) f init))
+
   clojure.lang.IObj
   (withMeta [this _]
     this)

src/xitdb/hash_map.clj

@@ -3,6 +3,7 @@
     [xitdb.common :as common]
     [xitdb.xitdb-util :as util])
   (:import
+    [clojure.core.protocols IKVReduce]
     (io.github.radarroark.xitdb ReadCursor ReadHashMap WriteCursor WriteHashMap)))
 
 (defn map-seq
@@ -11,6 +12,7 @@
   (util/map-seq rhm #(common/-read-from-cursor %)))
 
 (deftype XITDBHashMap [^ReadHashMap rhm]
+
   clojure.lang.ILookup
   (valAt [this key]
     (.valAt this key nil))
@@ -73,6 +75,9 @@
         (remove [_]
           (throw (UnsupportedOperationException. "XITDBHashMap iterator is read-only"))))))
 
+  clojure.core.protocols/IKVReduce
+  (kv-reduce [this f init]
+    (util/map-kv-reduce rhm #(common/-read-from-cursor %) f init))
 
   common/IUnwrap
   (-unwrap [this]
@@ -157,6 +162,10 @@
   (seq [this]
     (map-seq whm))
 
+  clojure.core.protocols/IKVReduce
+  (kv-reduce [this f init]
+    (util/map-kv-reduce whm #(common/-read-from-cursor %) f init))
+
   common/ISlot
   (-slot [this]
     (-> whm .cursor .slot))

src/xitdb/xitdb_util.clj

@@ -467,4 +467,37 @@
                         (lazy-seq (cons value (lazy-iter))))))]
     (lazy-iter)))
 
+(defn map-kv-reduce
+  "Efficiently reduces over key-value pairs in a ReadHashMap, skipping hidden keys."
+  [^ReadHashMap rhm read-from-cursor f init]
+  (let [it (.iterator rhm)]
+    (loop [result init]
+      (if (.hasNext it)
+        (let [cursor (.next it)
+              kv     (.readKeyValuePair cursor)
+              k      (read-bytes-with-format-tag (.-keyCursor kv))]
+          (if (contains? hidden-keys k)
+            (recur result)
+            (let [v (read-from-cursor (.-valueCursor kv))
+                  new-result (f result k v)]
+              (if (reduced? new-result)
+                @new-result
+                (recur new-result)))))
+        result))))
+
+(defn array-kv-reduce
+  "Efficiently reduces over index-value pairs in a ReadArrayList."
+  [^ReadArrayList ral read-from-cursor f init]
+  (let [count (.count ral)]
+    (loop [i 0
+           result init]
+      (if (< i count)
+        (let [cursor (.getCursor ral i)
+              v (read-from-cursor cursor)
+              new-result (f result i v)]
+          (if (reduced? new-result)
+            @new-result
+            (recur (inc i) new-result)))
+        result))))
+
 

test/xitdb/kv_reduce_test.clj

@@ -0,0 +1,64 @@
+(ns xitdb.kv-reduce-test
+  (:require
+    [clojure.test :refer :all]
+    [xitdb.test-utils :as tu :refer [with-db]]))
+
+(deftest kv-reduce-test
+  (with-db [db (tu/test-db)]
+    (testing "IKVReduce implementation for XITDBHashMap"
+      (reset! db {:a 1 :b 2 :c 3})
+      
+      ;; Test basic reduce operation
+      (let [sum (reduce-kv (fn [acc k v] (+ acc v)) 0 @db)]
+        (is (= 6 sum)))
+      
+      ;; Test early termination with reduced
+      (let [first-key (reduce-kv (fn [acc k v] (reduced k)) nil @db)]
+        (is (contains? #{:a :b :c} first-key)))
+      
+      ;; Test key-value accumulation
+      (let [kvs (reduce-kv (fn [acc k v] (conj acc [k v])) [] @db)]
+        (is (= 3 (count kvs)))
+        (is (every? #(and (keyword? (first %)) (number? (second %))) kvs)))
+      
+      ;; Test with nested maps
+      (reset! db {:outer {:inner {:value 42}}})
+      (let [nested-value (reduce-kv (fn [acc k v] 
+                                     (if (= k :outer)
+                                       (reduce-kv (fn [acc2 k2 v2]
+                                                   (if (= k2 :inner) 
+                                                     (get v2 :value)
+                                                     acc2)) acc v)
+                                       acc)) 
+                                   nil @db)]
+        (is (= 42 nested-value))))))
+
+(deftest array-kv-reduce-test
+  (with-db [db (tu/test-db)]
+    (testing "IKVReduce implementation for XITDBArrayList"
+      (reset! db [10 20 30 40])
+      
+      ;; Test basic reduce-kv operation (sum of indices * values)
+      (let [weighted-sum (reduce-kv (fn [acc idx val] (+ acc (* idx val))) 0 @db)]
+        (is (= 200 weighted-sum))) ; 0*10 + 1*20 + 2*30 + 3*40 = 0 + 20 + 60 + 120 = 200
+      
+      ;; Test early termination with reduced
+      (let [first-val (reduce-kv (fn [acc idx val] (reduced val)) nil @db)]
+        (is (= 10 first-val)))
+      
+      ;; Test index-value accumulation
+      (let [idx-vals (reduce-kv (fn [acc idx val] (conj acc [idx val])) [] @db)]
+        (is (= [[0 10] [1 20] [2 30] [3 40]] idx-vals)))
+      
+      ;; Test with nested vectors
+      (reset! db [[1 2] [3 4] [5 6]])
+      (let [sum-by-index (reduce-kv (fn [acc idx inner-vec] 
+                                     (+ acc (reduce-kv (fn [acc2 idx2 val2] 
+                                                        (+ acc2 (* idx idx2 val2))) 
+                                                      0 inner-vec)))
+                                   0 @db)]
+        ;; idx=0: 0*0*1 + 0*1*2 = 0
+        ;; idx=1: 1*0*3 + 1*1*4 = 4  
+        ;; idx=2: 2*0*5 + 2*1*6 = 12
+        ;; Total: 16
+        (is (= 16 sum-by-index))))))