document-dataply 0.0.9-alpha.12 → 0.0.9-alpha.13

package/dist/cjs/index.js

@@ -6485,21 +6485,68 @@ var require_cjs = __commonJS({
       }
       return (crc ^ -1) >>> 0;
     }
-    function getMinMaxValue(array) {
-      let i = 0;
-      let min = Infinity;
-      let max = -Infinity;
-      let len = array.length;
-      while (i < len) {
-        if (array[i] < min) {
-          min = array[i];
-        }
-        if (array[i] > max) {
-          max = array[i];
+    function calcThreshold(sortedGaps, n) {
+      const gLen = sortedGaps.length;
+      if (gLen === 0) return 0;
+      const median = sortedGaps[Math.floor(gLen * 0.5)];
+      const q1 = sortedGaps[Math.floor(gLen * 0.25)];
+      const q3 = sortedGaps[Math.floor(gLen * 0.75)];
+      const iqr = q3 - q1;
+      const logN = Math.max(1, Math.log10(n));
+      if (iqr > 0) {
+        const threshold2 = q3 + iqr * 1.5 * logN;
+        const minJump = Math.max(median * 5, 20);
+        return Math.max(threshold2, minJump);
+      }
+      const baseGap = median > 0 ? median : 1;
+      const p90 = sortedGaps[Math.floor(gLen * 0.9)];
+      if (p90 > baseGap) {
+        const threshold2 = baseGap + (p90 - baseGap) * 0.5 * logN;
+        return Math.max(threshold2, baseGap * 5, 20);
+      }
+      let mean = 0;
+      for (let i = 0; i < gLen; i++) mean += sortedGaps[i];
+      mean /= gLen;
+      let variance = 0;
+      for (let i = 0; i < gLen; i++) {
+        const d = sortedGaps[i] - mean;
+        variance += d * d;
+      }
+      const stddev = Math.sqrt(variance / gLen);
+      if (stddev === 0) {
+        return baseGap * 2;
+      }
+      const threshold = mean + stddev * logN;
+      return Math.max(threshold, baseGap * 5, 20);
+    }
+    function clusterNumbers(numbers, gapMultiplier) {
+      const n = numbers.length;
+      if (n === 0) return [];
+      if (n === 1) return [new Float64Array([numbers[0]])];
+      const sorted = (numbers instanceof Float64Array ? numbers.slice() : Float64Array.from(numbers)).sort();
+      const gaps = new Float64Array(n - 1);
+      for (let i = 0, len = n - 1; i < len; i++) {
+        gaps[i] = sorted[i + 1] - sorted[i];
+      }
+      const sortedGaps = gaps.slice().sort();
+      let threshold;
+      if (gapMultiplier !== void 0) {
+        const q3 = sortedGaps[Math.floor((n - 1) * 0.75)];
+        const iqr = q3 - sortedGaps[Math.floor((n - 1) * 0.25)];
+        threshold = q3 + iqr * gapMultiplier;
+      } else {
+        threshold = calcThreshold(sortedGaps, n);
+      }
+      const clusters = [];
+      let clusterStart = 0;
+      for (let i = 0, len = n - 1; i < len; i++) {
+        if (gaps[i] > threshold) {
+          clusters.push(sorted.subarray(clusterStart, i + 1));
+          clusterStart = i + 1;
         }
-        i++;
       }
-      return [min, max];
+      clusters.push(sorted.subarray(clusterStart));
+      return clusters;
     }
     var Row = class _Row {
       static CONSTANT = {
@@ -9439,14 +9486,30 @@ var require_cjs = __commonJS({
         for (let i = 0, len = pks.length; i < len; i++) {
           pkIndexMap.set(pks[i], i);
         }
-        const [minPk, maxPk] = getMinMaxValue(pks);
         const pkRidPairs = new Array(pks.length).fill(null);
         const btx = await this.getBPTreeTransaction(tx);
-        const stream = btx.whereStream({ gte: minPk, lte: maxPk });
-        for await (const [rid, pk] of stream) {
-          const index = pkIndexMap.get(pk);
-          if (index !== void 0) {
-            pkRidPairs[index] = { pk, rid, index };
+        const clusters = clusterNumbers(pks);
+        for (let i = 0, len = clusters.length; i < len; i++) {
+          const cluster = clusters[i];
+          const minPk = cluster[0];
+          const maxPk = cluster[cluster.length - 1];
+          if (minPk === maxPk) {
+            const keys = await btx.keys({ equal: minPk });
+            if (keys.size > 0) {
+              const rid = keys.values().next().value;
+              const index = pkIndexMap.get(minPk);
+              if (index !== void 0) {
+                pkRidPairs[index] = { pk: minPk, rid, index };
+              }
+            }
+            continue;
+          }
+          const stream = btx.whereStream({ gte: minPk, lte: maxPk });
+          for await (const [rid, pk] of stream) {
+            const index = pkIndexMap.get(pk);
+            if (index !== void 0) {
+              pkRidPairs[index] = { pk, rid, index };
+            }
           }
         }
         return this.fetchRowsByRids(pkRidPairs, tx);
@@ -11248,7 +11311,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     }
     candidates.sort((a, b) => b.score - a.score);
     const driver = candidates[0];
-    const others = candidates.slice(1);
+    const others = candidates.slice(1).filter((c) => c.field !== driver.field);
     const compositeVerifyConditions = [];
     for (const field of driver.compositeVerifyFields) {
       if (query[field]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.9-alpha.12",
+  "version": "0.0.9-alpha.13",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -42,7 +42,7 @@
     "dataply"
   ],
   "dependencies": {
-    "dataply": "^0.0.24-alpha.11"
+    "dataply": "^0.0.24-alpha.12"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",