wip

core/src/main/clojure/xtdb/operator/scan.clj

@@ -267,7 +267,9 @@
  sys-to-wtrs (vec
  (for [col-name col-names
  :when (= "xt$system_to" (util/str->normal-form-str col-name))]
- (.writerForName out-rel col-name types/temporal-col-type)))]
+ (.writerForName out-rel col-name types/temporal-col-type)))
+
+ !overlapping-ranges (ArrayList.)]
 
  (letfn [(duplicate-ptr [^ArrowBufPointer dst, ^ArrowBufPointer src]
  (.set dst (.getBuf src) (.getOffset src) (.getLength src)))
@@ -295,7 +297,25 @@
  (.writeLong sys-from-wtr sys-from))
  (doseq [^IVectorWriter sys-to-wtr sys-to-wtrs]
  (.writeLong sys-to-wtr sys-to))
- (.endRow out-rel)))]
+ (.endRow out-rel)))
+ (calc-overlapping-ranges [valid-from valid-to]
+ (let [^ListIterator itr (.iterator !ranges)
+ ^Rectangle cur (loop []
+ (when (.hasNext itr)
+ (let [^Rectangle next (.next itr)]
+ (if (<= (.valid-to next) valid-from)
+ (recur)
+ next))))]
+ (loop [^Rectangle cur cur]
+ (when cur
+ (if (< (.valid-from cur) valid-to)
+ (do
+ (.add !overlapping-ranges cur)
+ (.remove itr)
+ (recur (when (.hasNext itr) (.next itr))))
+ (when (<= valid-to (.valid-from cur))
+ (.previous itr)))))
+ itr))]
 
  (reify IntConsumer
  (accept [_ idx]
@@ -304,38 +324,18 @@
  (.clear !ranges)
  (duplicate-ptr prev-iid-ptr current-iid-ptr))
 
- (print-rectangles "ranges" !ranges)
  (assert (ranges-invariant !ranges))
 
  (if (= :evict (.getLeg op-rdr idx))
  (duplicate-ptr skip-iid-ptr current-iid-ptr)
- (let [!overlapping-ranges (ArrayList.)
-  system-from (.getLong sys-from-rdr idx)]
+ (let [system-from (.getLong sys-from-rdr idx)]
+ (.clear !overlapping-ranges)
  (when (and (<= sys-from-lower system-from) (<= system-from sys-from-upper))
  (case (.getLeg op-rdr idx)
  :put
  (let [valid-from (.getLong put-valid-from-rdr idx)
  valid-to (.getLong put-valid-to-rdr idx)
- ^ListIterator itr (.iterator !ranges)
- ^Rectangle cur (loop []
- (when (.hasNext itr)
- (let [^Rectangle next (.next itr)]
- (if (<= (.valid-to next) valid-from)
- (recur)
- next))))]
-
- (loop [^Rectangle cur cur]
- (when cur
- (if (< (.valid-from cur) valid-to)
- (do
- (.add !overlapping-ranges cur)
- (.remove itr)
- (recur (when (.hasNext itr) (.next itr))))
- (when (<= valid-to (.valid-from cur))
- (.previous itr)))))
-
- (println (util/micros->instant valid-from) (util/micros->instant valid-to))
- (print-rectangles "overlapping" !overlapping-ranges)
+ ^ListIterator itr (calc-overlapping-ranges valid-from valid-to)]
 
  (when-let [^Rectangle begin (first !overlapping-ranges)]
  (when (< (.valid-from begin) valid-from)
@@ -345,18 +345,17 @@
 
  (if (seq !overlapping-ranges)
  (do
- (doall (map (fn [^Rectangle r1 ^Rectangle r2]
+ (dorun (map (fn [^Rectangle r1 ^Rectangle r2]
  (when (< (.valid-to r1) (.valid-from r2))
  (write-r idx (.valid-to r1) (.valid-from r2) system-from util/end-of-time-μs)))
  !overlapping-ranges (rest !overlapping-ranges)))
 
  (when range-range?
- (run! (fn [^Rectangle r]
- (let [new-valid-from (max valid-from (.valid-from r))
- new-valid-to (min valid-to (.valid-to r))]
- (when (< new-valid-from new-valid-to)
- (write-r idx new-valid-from new-valid-to system-from (.sys-from r)))))
- !overlapping-ranges)))
+ (doseq [^Rectangle r !overlapping-ranges]
+ (let [new-valid-from (max valid-from (.valid-from r))
+ new-valid-to (min valid-to (.valid-to r))]
+ (when (< new-valid-from new-valid-to)
+ (write-r idx new-valid-from new-valid-to system-from (.sys-from r)))))))
  (write-r idx valid-from valid-to system-from util/end-of-time-μs))
 
  (.add itr (Rectangle. valid-from valid-to system-from util/end-of-time-μs))
@@ -370,23 +369,7 @@
  :delete
  (let [valid-from (.getLong delete-valid-from-rdr idx)
  valid-to (.getLong delete-valid-to-rdr idx)
- ^ListIterator itr (.iterator !ranges)
- ^Rectangle cur (loop []
- (when (.hasNext itr)
- (let [^Rectangle next (.next itr)]
- (if (<= (.valid-to next) valid-from)
- (recur)
- next))))]
-
- (loop [^Rectangle cur cur]
- (when cur
- (if (< (.valid-from cur) valid-to)
- (do
- (.add !overlapping-ranges cur)
- (.remove itr)
- (recur (when (.hasNext itr) (.next itr))))
- (when (<= valid-to (.valid-from cur))
- (.previous itr)))))
+ ^ListIterator itr (calc-overlapping-ranges valid-from valid-to)]
 
  (when-let [^Rectangle begin (first !overlapping-ranges)]
  (when (< (.valid-from begin) valid-from)