dataply 0.0.21-alpha.0 → 0.0.21

package/dist/cjs/index.js

@@ -5695,31 +5695,31 @@ function numberToBytes(value, buffer, offset = 0, length = buffer.length) {
 }
 
 // src/utils/bytesToNumber.ts
+var tempBuffer = new ArrayBuffer(8);
+var tempView = new DataView(tempBuffer);
+var tempArray = new Uint8Array(tempBuffer);
 function bytesToNumber(bytes, offset = 0, length = bytes.length) {
-  if (length === 4) {
-    return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
-  }
-  if (length === 8) {
-    const low2 = (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
-    const high = (bytes[offset + 4] | bytes[offset + 5] << 8 | bytes[offset + 6] << 16 | bytes[offset + 7] << 24) >>> 0;
-    return low2 + high * 4294967296;
+  tempArray.set(bytes.subarray(offset, offset + length));
+  switch (length) {
+    case 1:
+      return tempView.getUint8(0);
+    case 2:
+      return tempView.getUint16(0, true);
+    case 3:
+      return tempView.getUint16(0, true) + (tempView.getUint8(2) << 16);
+    case 4:
+      return tempView.getUint32(0, true);
+    case 5:
+      return tempView.getUint32(0, true) + tempView.getUint8(4) * 4294967296;
+    case 6:
+      return tempView.getUint32(0, true) + tempView.getUint16(4, true) * 4294967296;
+    case 7:
+      return tempView.getUint32(0, true) + (tempView.getUint16(4, true) + (tempView.getUint8(6) << 16)) * 4294967296;
+    case 8:
+      return tempView.getUint32(0, true) + tempView.getUint32(4, true) * 4294967296;
+    default:
+      return 0;
   }
-  let low = 0;
-  const lenLow = length < 4 ? length : 4;
-  for (let i = 0; i < lenLow; i++) {
-    low |= bytes[offset + i] << i * 8;
-  }
-  low >>>= 0;
-  if (length > 4) {
-    let high = 0;
-    const lenHigh = length < 8 ? length : 8;
-    for (let i = 4; i < lenHigh; i++) {
-      high |= bytes[offset + i] << (i - 4) * 8;
-    }
-    high >>>= 0;
-    return low + high * 4294967296;
-  }
-  return low;
 }
 
 // src/utils/bitwise.ts
@@ -8301,7 +8301,7 @@ var RowTableEngine = class {
     this.maxBodySize = this.pfs.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
     this.order = this.getOptimalOrder(pfs.pageSize, IndexPageManager.CONSTANT.SIZE_KEY, IndexPageManager.CONSTANT.SIZE_VALUE);
     this.strategy = new RowIdentifierStrategy(this.order, pfs, txContext);
-    const budget = import_node_os.default.freemem() * 0.1;
+    const budget = import_node_os.default.totalmem() * 0.1;
     const nodeMemory = this.order * 24 + 256;
     const capacity = Math.max(1e3, Math.min(1e6, Math.floor(budget / nodeMemory)));
     this.bptree = new BPTreeAsync(
@@ -8686,41 +8686,44 @@ var RowTableEngine = class {
     if (pks.length === 0) {
       return [];
     }
+    const pkIndexMap = /* @__PURE__ */ new Map();
+    for (let i = 0, len = pks.length; i < len; i++) {
+      pkIndexMap.set(pks[i], i);
+    }
     const minPk = Math.min(...pks);
     const maxPk = Math.max(...pks);
-    const pkSet = new Set(pks);
-    const pkRidPairs = [];
+    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) {
-      if (pkSet.has(pk)) {
-        pkRidPairs.push({ pk, rid });
+      const index = pkIndexMap.get(pk);
+      if (index !== void 0) {
+        pkRidPairs[index] = { pk, rid, index };
       }
     }
-    const resultMap = await this.fetchRowsByRids(pkRidPairs, tx);
-    return pks.map((pk) => resultMap.get(pk) ?? null);
+    return this.fetchRowsByRids(pkRidPairs, tx);
   }
   /**
    * Fetches multiple rows by their RID and PK combinations, grouping by page ID to minimize I/O.
    * @param pkRidPairs Array of {pk, rid} pairs
    * @param tx Transaction
-   * @returns Map of PK to row data
+   * @returns Array of row data in the same order as input PKs
    */
   async fetchRowsByRids(pkRidPairs, tx) {
-    const resultMap = /* @__PURE__ */ new Map();
-    if (pkRidPairs.length === 0) return resultMap;
+    const result = new Array(pkRidPairs.length).fill(null);
+    if (pkRidPairs.length === 0) return result;
     const pageGroupMap = /* @__PURE__ */ new Map();
     for (const pair of pkRidPairs) {
+      if (pair === null) continue;
       const rid = pair.rid;
       const slotIndex = rid % 65536;
       const pageId = Math.floor(rid / 65536);
       if (!pageGroupMap.has(pageId)) {
         pageGroupMap.set(pageId, []);
       }
-      pageGroupMap.get(pageId).push({ pk: pair.pk, slotIndex });
+      pageGroupMap.get(pageId).push({ pk: pair.pk, slotIndex, index: pair.index });
     }
-    const sortedPageEntries = Array.from(pageGroupMap.entries()).sort((a, b) => a[0] - b[0]);
-    await Promise.all(sortedPageEntries.map(async ([pageId, items]) => {
+    await Promise.all(Array.from(pageGroupMap).map(async ([pageId, items]) => {
       const page = await this.pfs.get(pageId, tx);
       if (!this.factory.isDataPage(page)) {
         throw new Error(`Page ${pageId} is not a data page`);
@@ -8729,17 +8732,17 @@ var RowTableEngine = class {
       for (const item of items) {
         const row = manager.getRow(page, item.slotIndex);
         if (this.rowManager.getDeletedFlag(row)) {
-          resultMap.set(item.pk, null);
+          result[item.index] = null;
         } else if (this.rowManager.getOverflowFlag(row)) {
           const overflowPageId = bytesToNumber(this.rowManager.getBody(row));
           const body = await this.pfs.getBody(overflowPageId, true, tx);
-          resultMap.set(item.pk, body);
+          result[item.index] = body;
         } else {
-          resultMap.set(item.pk, this.rowManager.getBody(row));
+          result[item.index] = this.rowManager.getBody(row);
         }
       }
     }));
-    return resultMap;
+    return result;
   }
   async fetchRowByRid(pk, rid, tx) {
     this.keyManager.setBufferFromKey(rid, this.ridBuffer);

package/dist/types/core/Dataply.d.ts

@@ -75,9 +75,9 @@ export declare class Dataply {
      * @param tx Transaction
      * @returns Array of selected data in the same order as input PKs
      */
-    selectMany(pks: number[], asRaw: true, tx?: Transaction): Promise<(Uint8Array | null)[]>;
-    selectMany(pks: number[], asRaw: false, tx?: Transaction): Promise<(string | null)[]>;
-    selectMany(pks: number[], asRaw?: boolean, tx?: Transaction): Promise<(string | null)[]>;
+    selectMany(pks: number[] | Float64Array, asRaw: true, tx?: Transaction): Promise<(Uint8Array | null)[]>;
+    selectMany(pks: number[] | Float64Array, asRaw: false, tx?: Transaction): Promise<(string | null)[]>;
+    selectMany(pks: number[] | Float64Array, asRaw?: boolean, tx?: Transaction): Promise<(string | null)[]>;
     /**
      * Closes the dataply file.
      */

package/dist/types/core/DataplyAPI.d.ts

@@ -164,9 +164,9 @@ export declare class DataplyAPI {
      * @param tx Transaction
      * @returns Array of selected data in the same order as input PKs
      */
-    selectMany(pks: number[], asRaw: true, tx?: Transaction): Promise<(Uint8Array | null)[]>;
-    selectMany(pks: number[], asRaw: false, tx?: Transaction): Promise<(string | null)[]>;
-    selectMany(pks: number[], asRaw?: boolean, tx?: Transaction): Promise<(string | null)[]>;
+    selectMany(pks: number[] | Float64Array, asRaw: true, tx?: Transaction): Promise<(Uint8Array | null)[]>;
+    selectMany(pks: number[] | Float64Array, asRaw: false, tx?: Transaction): Promise<(string | null)[]>;
+    selectMany(pks: number[] | Float64Array, asRaw?: boolean, tx?: Transaction): Promise<(string | null)[]>;
     /**
      * Closes the dataply file.
      */

package/dist/types/core/RowTableEngine.d.ts

@@ -130,12 +130,12 @@ export declare class RowTableEngine {
      * @param tx Transaction
      * @returns Array of raw data of the rows in the same order as input PKs
      */
-    selectMany(pks: number[], tx: Transaction): Promise<(Uint8Array | null)[]>;
+    selectMany(pks: number[] | Float64Array, tx: Transaction): Promise<(Uint8Array | null)[]>;
     /**
      * Fetches multiple rows by their RID and PK combinations, grouping by page ID to minimize I/O.
      * @param pkRidPairs Array of {pk, rid} pairs
      * @param tx Transaction
-     * @returns Map of PK to row data
+     * @returns Array of row data in the same order as input PKs
      */
     private fetchRowsByRids;
     private fetchRowByRid;

package/dist/types/utils/binarySearch.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Performs a binary search on a sorted array.
+ * @param array Sorted array to search in
+ * @param comparator Function that returns 0 if the element matches, < 0 if the target is before, > 0 if the target is after
+ * @returns Index of the element if found, -1 otherwise
+ */
+export declare function binarySearch<T>(array: ArrayLike<T>, comparator: (element: T) => number): number;
+/**
+ * Performs a binary search on a sorted numeric array.
+ * @param array Sorted numeric array to search in
+ * @param target Numeric value to search for
+ * @returns Index of the element if found, -1 otherwise
+ */
+export declare function binarySearchNumeric(array: ArrayLike<number>, target: number): number;

package/dist/types/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from './numberToBytes';
 export * from './bytesToNumber';
 export * from './bitwise';
 export * from './crc32';
+export * from './binarySearch';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.21-alpha.0",
+  "version": "0.0.21",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -51,4 +51,4 @@
     "ryoiki": "^1.2.0",
     "serializable-bptree": "^8.1.2"
   }
-}
+}