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

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);
@@ -10934,7 +10997,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         const doc = await this.getDocument(k, tx2);
         if (!doc) continue;
         const flatDoc = this.flattenDocument(doc);
-        for (const indexName of backfillTargets) {
+        for (let i = 0, len = backfillTargets.length; i < len; i++) {
+          const indexName = backfillTargets[i];
           if (!(indexName in indexTxMap)) continue;
           const config = this.registeredIndices.get(indexName);
           if (!config) continue;
@@ -10946,8 +11010,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
             const ftsConfig = this.getFtsConfig(config);
             const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
             const batchInsertData = [];
-            for (let i = 0, len = tokens.length; i < len; i++) {
-              const token = tokens[i];
+            for (let i2 = 0, len2 = tokens.length; i2 < len2; i2++) {
+              const token = tokens[i2];
               const keyToInsert = this.getTokenKey(k, token);
               const entry = { k, v: token };
               batchInsertData.push([keyToInsert, entry]);
@@ -11148,13 +11212,18 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       if (config.type === "btree") {
         const primaryField = config.fields[0];
         if (!queryFields.has(primaryField)) continue;
-        const condition = query[primaryField];
         const treeTx = await tree.createTransaction();
+        const builtCondition = {};
         let score = 0;
         let isConsecutive = true;
         const coveredFields = [];
         const compositeVerifyFields = [];
-        for (const field of config.fields) {
+        const startValues = [];
+        const endValues = [];
+        let startOperator = null;
+        let endOperator = null;
+        for (let i = 0, len = config.fields.length; i < len; i++) {
+          const field = config.fields[i];
           if (!queryFields.has(field)) {
             isConsecutive = false;
             continue;
@@ -11169,11 +11238,53 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
             if (cond !== void 0) {
               if (typeof cond !== "object" || cond === null) {
                 score += 100;
+                startValues.push(cond);
+                endValues.push(cond);
+                startOperator = "primaryGte";
+                endOperator = "primaryLte";
               } else if ("primaryEqual" in cond || "equal" in cond) {
+                const val = cond.primaryEqual?.v ?? cond.equal?.v ?? cond.primaryEqual ?? cond.equal;
                 score += 100;
-              } else if ("primaryGte" in cond || "primaryLte" in cond || "primaryGt" in cond || "primaryLt" in cond || "gte" in cond || "lte" in cond || "gt" in cond || "lt" in cond) {
+                startValues.push(val);
+                endValues.push(val);
+                startOperator = "primaryGte";
+                endOperator = "primaryLte";
+              } else if ("primaryGte" in cond || "gte" in cond) {
+                const val = cond.primaryGte?.v ?? cond.gte?.v ?? cond.primaryGte ?? cond.gte;
+                score += 50;
+                isConsecutive = false;
+                startValues.push(val);
+                startOperator = "primaryGte";
+                if (endValues.length > 0) {
+                  endOperator = "primaryLte";
+                }
+              } else if ("primaryGt" in cond || "gt" in cond) {
+                const val = cond.primaryGt?.v ?? cond.gt?.v ?? cond.primaryGt ?? cond.gt;
+                score += 50;
+                isConsecutive = false;
+                startValues.push(val);
+                startOperator = "primaryGt";
+                if (endValues.length > 0) {
+                  endOperator = "primaryLte";
+                }
+              } else if ("primaryLte" in cond || "lte" in cond) {
+                const val = cond.primaryLte?.v ?? cond.lte?.v ?? cond.primaryLte ?? cond.lte;
+                score += 50;
+                isConsecutive = false;
+                endValues.push(val);
+                endOperator = "primaryLte";
+                if (startValues.length > 0) {
+                  startOperator = "primaryGte";
+                }
+              } else if ("primaryLt" in cond || "lt" in cond) {
+                const val = cond.primaryLt?.v ?? cond.lt?.v ?? cond.primaryLt ?? cond.lt;
                 score += 50;
                 isConsecutive = false;
+                endValues.push(val);
+                endOperator = "primaryLt";
+                if (startValues.length > 0) {
+                  startOperator = "primaryGte";
+                }
               } else if ("primaryOr" in cond || "or" in cond) {
                 score += 20;
                 isConsecutive = false;
@@ -11187,9 +11298,28 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
             }
           }
         }
+        if (coveredFields.length === 1 && config.fields.length === 1) {
+          Object.assign(builtCondition, query[primaryField]);
+        } else {
+          if (startOperator && startValues.length > 0) {
+            builtCondition[startOperator] = { v: startValues.length === 1 ? startValues[0] : startValues };
+          }
+          if (endOperator && endValues.length > 0) {
+            if (startOperator && startValues.length === endValues.length && startValues.every((val, i) => val === endValues[i])) {
+              delete builtCondition[startOperator];
+              builtCondition["primaryEqual"] = { v: startValues.length === 1 ? startValues[0] : startValues };
+            } else {
+              builtCondition[endOperator] = { v: endValues.length === 1 ? endValues[0] : endValues };
+            }
+          }
+          if (Object.keys(builtCondition).length === 0) {
+            Object.assign(builtCondition, query[primaryField] || {});
+          }
+        }
         let isIndexOrderSupported = false;
         if (orderByField) {
-          for (const field of config.fields) {
+          for (let i = 0, len = config.fields.length; i < len; i++) {
+            const field = config.fields[i];
             if (field === orderByField) {
               isIndexOrderSupported = true;
               break;
@@ -11208,7 +11338,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         }
         candidates.push({
           tree: treeTx,
-          condition,
+          condition: builtCondition,
           field: primaryField,
           indexName,
           isFtsMatch: false,
@@ -11246,11 +11376,19 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       rollback();
       return null;
     }
-    candidates.sort((a, b) => b.score - a.score);
+    candidates.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      const aConfig = this.registeredIndices.get(a.indexName);
+      const bConfig = this.registeredIndices.get(b.indexName);
+      const aFieldCount = aConfig ? Array.isArray(aConfig.fields) ? aConfig.fields.length : 1 : 0;
+      const bFieldCount = bConfig ? Array.isArray(bConfig.fields) ? bConfig.fields.length : 1 : 0;
+      return aFieldCount - bFieldCount;
+    });
     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) {
+    for (let i = 0, len = driver.compositeVerifyFields.length; i < len; i++) {
+      const field = driver.compositeVerifyFields[i];
       if (query[field]) {
         compositeVerifyConditions.push({ field, condition: query[field] });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.9-alpha.12",
+  "version": "0.0.9-alpha.14",
   "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",
@@ -51,4 +51,4 @@
     "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   }
-}
+}