xitdb 0.13.0 → 0.15.0

package/dist/core-memory.js

@@ -0,0 +1,152 @@
+export class CoreMemory {
+    memory;
+    constructor() {
+        this.memory = new RandomAccessMemory();
+    }
+    reader() {
+        return this.memory;
+    }
+    writer() {
+        return this.memory;
+    }
+    length() {
+        return this.memory.size();
+    }
+    seek(pos) {
+        this.memory.seek(pos);
+    }
+    position() {
+        return this.memory.getPosition();
+    }
+    setLength(len) {
+        this.memory.setLength(len);
+    }
+    flush() {
+        // no-op for in-memory
+    }
+    sync() {
+        // no-op for in-memory
+    }
+}
+class RandomAccessMemory {
+    buffer;
+    _position = 0;
+    _count = 0;
+    constructor(initialSize = 1024) {
+        this.buffer = new Uint8Array(initialSize);
+    }
+    ensureCapacity(minCapacity) {
+        if (minCapacity > this.buffer.length) {
+            let newCapacity = this.buffer.length * 2;
+            if (newCapacity < minCapacity) {
+                newCapacity = minCapacity;
+            }
+            const newBuffer = new Uint8Array(newCapacity);
+            newBuffer.set(this.buffer.subarray(0, this._count));
+            this.buffer = newBuffer;
+        }
+    }
+    size() {
+        return this._count;
+    }
+    seek(pos) {
+        if (pos > this._count) {
+            this._position = this._count;
+        }
+        else {
+            this._position = pos;
+        }
+    }
+    getPosition() {
+        return this._position;
+    }
+    setLength(len) {
+        if (len === 0) {
+            this.reset();
+        }
+        else {
+            if (len > this._count)
+                throw new Error('Cannot extend length');
+            this._count = len;
+            if (this._position > len) {
+                this._position = len;
+            }
+        }
+    }
+    reset() {
+        this._count = 0;
+        this._position = 0;
+    }
+    toByteArray() {
+        return this.buffer.slice(0, this._count);
+    }
+    // DataWriter interface
+    write(data) {
+        const pos = this._position;
+        if (pos < this._count) {
+            const bytesBeforeEnd = Math.min(data.length, this._count - pos);
+            for (let i = 0; i < bytesBeforeEnd; i++) {
+                this.buffer[pos + i] = data[i];
+            }
+            if (bytesBeforeEnd < data.length) {
+                const bytesAfterEnd = data.length - bytesBeforeEnd;
+                this.ensureCapacity(this._count + bytesAfterEnd);
+                this.buffer.set(data.subarray(bytesBeforeEnd), this._count);
+                this._count += bytesAfterEnd;
+            }
+        }
+        else {
+            this.ensureCapacity(this._count + data.length);
+            this.buffer.set(data, this._count);
+            this._count += data.length;
+        }
+        this._position = pos + data.length;
+    }
+    writeByte(v) {
+        this.write(new Uint8Array([v & 0xff]));
+    }
+    writeShort(v) {
+        const buffer = new ArrayBuffer(2);
+        const view = new DataView(buffer);
+        view.setInt16(0, v, false); // big-endian
+        this.write(new Uint8Array(buffer));
+    }
+    writeLong(v) {
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+        view.setBigInt64(0, BigInt(v), false);
+        this.write(new Uint8Array(buffer));
+    }
+    // DataReader interface
+    readFully(b) {
+        const pos = this._position;
+        if (pos + b.length > this._count) {
+            throw new Error('End of stream');
+        }
+        b.set(this.buffer.subarray(pos, pos + b.length));
+        this._position = pos + b.length;
+    }
+    readByte() {
+        const bytes = new Uint8Array(1);
+        this.readFully(bytes);
+        return bytes[0];
+    }
+    readShort() {
+        const bytes = new Uint8Array(2);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt16(0, false); // big-endian
+    }
+    readInt() {
+        const bytes = new Uint8Array(4);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt32(0, false); // big-endian
+    }
+    readLong() {
+        const bytes = new Uint8Array(8);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return Number(view.getBigInt64(0, false));
+    }
+}

package/dist/core.js

@@ -0,0 +1 @@
+export {};

package/dist/database.d.ts

@@ -1,19 +1,24 @@
-import type { Core } from './core';
-import { Hasher } from './hasher';
-import { Tag } from './tag';
-import { Slot } from './slot';
-import { SlotPointer } from './slot-pointer';
-import { type WriteableData } from './writeable-data';
-import { WriteCursor } from './write-cursor';
+import type { Core } from './core.js';
+import { Hasher } from './hasher.js';
+import { Tag } from './tag.js';
+import { Slot } from './slot.js';
+import { SlotPointer } from './slot-pointer.js';
+import { type WriteableData } from './writeable-data.js';
+import { WriteCursor } from './write-cursor.js';
 export declare const VERSION = 0;
 export declare const MAGIC_NUMBER: Uint8Array<ArrayBuffer>;
 export declare const BIT_COUNT = 4;
 export declare const SLOT_COUNT: number;
 export declare const MASK: bigint;
 export declare const INDEX_BLOCK_SIZE: number;
-export declare const LINKED_ARRAY_LIST_SLOT_LENGTH: number;
-export declare const LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE: number;
 export declare const MAX_BRANCH_LENGTH = 16;
+export declare const BTREE_SLOT_COUNT: number;
+export declare const BTREE_SPLIT_COUNT: number;
+export declare const BTREE_NODE_HEADER_SIZE = 2;
+export declare const BTREE_LEAF_BLOCK_SIZE: number;
+export declare const BTREE_BRANCH_BLOCK_SIZE: number;
+export declare const SORTED_LEAF_BLOCK_SIZE: number;
+export declare const SORTED_BRANCH_BLOCK_SIZE: number;
 export declare enum WriteMode {
     READ_ONLY = 0,
     READ_WRITE = 1
@@ -48,15 +53,13 @@ export declare class TopLevelArrayListHeader {
     constructor(fileSize: number, parent: ArrayListHeader);
     toBytes(): Uint8Array;
 }
-export declare class LinkedArrayListHeader {
-    shift: number;
-    ptr: number;
+export declare class BTreeHeader {
+    rootPtr: number;
     size: number;
-    static readonly LENGTH = 17;
-    constructor(shift: number, ptr: number, size: number);
+    static readonly LENGTH = 16;
+    constructor(rootPtr: number, size: number);
     toBytes(): Uint8Array;
-    static fromBytes(bytes: Uint8Array): LinkedArrayListHeader;
-    withPtr(ptr: number): LinkedArrayListHeader;
+    static fromBytes(bytes: Uint8Array): BTreeHeader;
 }
 export declare class KeyValuePair {
     valueSlot: Slot;
@@ -67,28 +70,89 @@ export declare class KeyValuePair {
     toBytes(): Uint8Array;
     static fromBytes(bytes: Uint8Array, hashSize: number): KeyValuePair;
 }
-export declare class LinkedArrayListSlot {
-    size: number;
+export declare enum BTreeNodeKind {
+    LEAF = 0,
+    BRANCH = 1
+}
+export declare class BTreeNode {
+    kind: BTreeNodeKind;
+    num: number;
+    values: Slot[];
+    children: Slot[];
+    counts: number[];
+    constructor(kind: BTreeNodeKind, num: number);
+    subtreeCount(): number;
+}
+export declare class BTreeNodeRef {
+    nodePtr: number;
+    count: number;
+    constructor(nodePtr: number, count: number);
+}
+export declare class BTreeInsertResult {
+    nodePtr: number;
+    count: number;
+    valuePosition: number;
+    split: BTreeNodeRef | null;
+    constructor(nodePtr: number, count: number, valuePosition: number, split: BTreeNodeRef | null);
+}
+export declare class BTreeWriteSlot {
+    nodePtr: number;
+    valuePosition: number;
     slot: Slot;
-    static readonly LENGTH: number;
-    constructor(size: number, slot: Slot);
-    withSize(size: number): LinkedArrayListSlot;
-    toBytes(): Uint8Array;
-    static fromBytes(bytes: Uint8Array): LinkedArrayListSlot;
-}
-export declare class LinkedArrayListSlotPointer {
-    slotPtr: SlotPointer;
-    leafCount: number;
-    constructor(slotPtr: SlotPointer, leafCount: number);
-    withSlotPointer(slotPtr: SlotPointer): LinkedArrayListSlotPointer;
+    constructor(nodePtr: number, valuePosition: number, slot: Slot);
+}
+export declare class BTreeJoinResult {
+    nodePtr: number;
+    count: number;
+    split: BTreeNodeRef | null;
+    constructor(nodePtr: number, count: number, split: BTreeNodeRef | null);
+}
+export declare class BTreeSplitResult {
+    left: number;
+    right: number;
+    constructor(left: number, right: number);
+}
+export declare class SortedNode {
+    kind: BTreeNodeKind;
+    num: number;
+    entries: Slot[];
+    children: Slot[];
+    separators: Slot[];
+    counts: number[];
+    constructor(kind: BTreeNodeKind, num: number);
+    subtreeCount(): number;
+}
+export declare class SortedSplit {
+    nodePtr: number;
+    count: number;
+    separator: Slot;
+    constructor(nodePtr: number, count: number, separator: Slot);
+}
+export declare class SortedInsertResult {
+    nodePtr: number;
+    count: number;
+    valuePosition: number;
+    added: boolean;
+    split: SortedSplit | null;
+    constructor(nodePtr: number, count: number, valuePosition: number, added: boolean, split: SortedSplit | null);
+}
+export declare class SortedRemoveResult {
+    nodePtr: number;
+    found: boolean;
+    constructor(nodePtr: number, found: boolean);
+}
+export declare class SortedSlot {
+    slot: Slot;
+    position: number;
+    constructor(slot: Slot, position: number);
 }
-export declare class LinkedArrayListBlockInfo {
-    block: LinkedArrayListSlot[];
-    i: number;
-    parentSlot: LinkedArrayListSlot;
-    constructor(block: LinkedArrayListSlot[], i: number, parentSlot: LinkedArrayListSlot);
+export declare class SortedEntry {
+    kvSlot: Slot;
+    keySlot: Slot;
+    valuePosition: number;
+    constructor(kvSlot: Slot, keySlot: Slot, valuePosition: number);
 }
-export type PathPart = ArrayListInit | ArrayListGet | ArrayListAppend | ArrayListSlice | LinkedArrayListInit | LinkedArrayListGet | LinkedArrayListAppend | LinkedArrayListSlice | LinkedArrayListConcat | LinkedArrayListInsert | LinkedArrayListRemove | HashMapInit | HashMapGet | HashMapRemove | WriteData | Context;
+export type PathPart = ArrayListInit | ArrayListGet | ArrayListAppend | ArrayListSlice | LinkedArrayListInit | LinkedArrayListGet | LinkedArrayListAppend | LinkedArrayListSlice | LinkedArrayListConcat | LinkedArrayListInsert | LinkedArrayListRemove | HashMapInit | HashMapGet | HashMapRemove | SortedMapInit | SortedMapGet | SortedMapGetIndex | SortedMapRemove | WriteData | Context;
 export interface PathPartBase {
     readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
@@ -108,6 +172,22 @@ export declare class HashMapGetValue {
     readonly kind = "value";
     constructor(hash: Uint8Array);
 }
+export type SortedMapGetTarget = SortedMapGetKVPair | SortedMapGetKey | SortedMapGetValue;
+export declare class SortedMapGetKVPair {
+    key: Uint8Array;
+    readonly kind = "kv_pair";
+    constructor(key: Uint8Array);
+}
+export declare class SortedMapGetKey {
+    key: Uint8Array;
+    readonly kind = "key";
+    constructor(key: Uint8Array);
+}
+export declare class SortedMapGetValue {
+    key: Uint8Array;
+    readonly kind = "value";
+    constructor(key: Uint8Array);
+}
 export type ContextFunction = (cursor: any) => void;
 export declare class ArrayListInit implements PathPartBase {
     readonly kind = "ArrayListInit";
@@ -187,6 +267,30 @@ export declare class HashMapRemove implements PathPartBase {
     constructor(hash: Uint8Array);
     readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
+export declare class SortedMapInit implements PathPartBase {
+    set: boolean;
+    readonly kind = "SortedMapInit";
+    constructor(set?: boolean);
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
+}
+export declare class SortedMapGet implements PathPartBase {
+    target: SortedMapGetTarget;
+    readonly kind = "SortedMapGet";
+    constructor(target: SortedMapGetTarget);
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
+}
+export declare class SortedMapGetIndex implements PathPartBase {
+    index: number;
+    readonly kind = "SortedMapGetIndex";
+    constructor(index: number);
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
+}
+export declare class SortedMapRemove implements PathPartBase {
+    key: Uint8Array;
+    readonly kind = "SortedMapRemove";
+    constructor(key: Uint8Array);
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
+}
 export declare class WriteData implements PathPartBase {
     data: WriteableData | null;
     readonly kind = "WriteData";
@@ -209,11 +313,6 @@ declare class ArrayListAppendResult {
     slotPtr: SlotPointer;
     constructor(header: ArrayListHeader, slotPtr: SlotPointer);
 }
-declare class LinkedArrayListAppendResult {
-    header: LinkedArrayListHeader;
-    slotPtr: LinkedArrayListSlotPointer;
-    constructor(header: LinkedArrayListHeader, slotPtr: LinkedArrayListSlotPointer);
-}
 export declare class Database {
     core: Core;
     hasher: Hasher;
@@ -232,14 +331,40 @@ export declare class Database {
     readArrayListSlotAppend(header: ArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): ArrayListAppendResult;
     readArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): SlotPointer;
     readArrayListSlice(header: ArrayListHeader, size: number): ArrayListHeader;
-    readLinkedArrayListSlotAppend(header: LinkedArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): LinkedArrayListAppendResult;
-    private static blockLeafCount;
-    private static slotLeafCount;
-    private static keyAndIndexForLinkedArrayList;
-    readLinkedArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): LinkedArrayListSlotPointer;
-    readLinkedArrayListBlocks(indexPos: number, key: number, shift: number, blocks: LinkedArrayListBlockInfo[]): void;
-    private populateArray;
-    readLinkedArrayListSlice(header: LinkedArrayListHeader, offset: number, size: number): LinkedArrayListHeader;
-    readLinkedArrayListConcat(headerA: LinkedArrayListHeader, headerB: LinkedArrayListHeader): LinkedArrayListHeader;
+    readBTreeNode(ptr: number): BTreeNode;
+    writeBTreeNodeAt(node: BTreeNode, ptr: number): void;
+    writeBTreeNode(node: BTreeNode): number;
+    btreeReusable(ptr: number): boolean;
+    btreeWriteNode(node: BTreeNode, oldPtr: number): number;
+    btreeNewRoot(): number;
+    readBTreeSlot(rootPtr: number, rank: number): SlotPointer;
+    btreeInsert(nodePtr: number, rank: number): BTreeInsertResult;
+    btreeGrowRoot(result: BTreeInsertResult): number;
+    btreeGetForWrite(nodePtr: number, rank: number): BTreeWriteSlot;
+    btreeHeight(rootPtr: number): number;
+    btreeMakeRoot(result: BTreeJoinResult): number;
+    btreeAssembleLeaf(vals: Slot[], total: number): BTreeJoinResult;
+    btreeAssembleBranch(children: Slot[], counts: number[], total: number): BTreeJoinResult;
+    btreeMergeNodes(a: BTreeNode, b: BTreeNode): BTreeJoinResult;
+    btreeJoinRight(aPtr: number, ha: number, bPtr: number, hb: number): BTreeJoinResult;
+    btreeJoinLeft(aPtr: number, ha: number, bPtr: number, hb: number): BTreeJoinResult;
+    btreeJoin(rootA: number, rootB: number): number;
+    btreeSubtree(children: Slot[], counts: number[], start: number, len: number): number;
+    btreeSplit(rootPtr: number, rank: number): BTreeSplitResult;
+    readSortedNode(ptr: number): SortedNode;
+    writeSortedNodeAt(node: SortedNode, ptr: number): void;
+    writeSortedNode(node: SortedNode): number;
+    sortedWriteNode(node: SortedNode, oldPtr: number): number;
+    readKvPair(kvSlot: Slot): KeyValuePair;
+    compareKey(keySlot: Slot, target: Uint8Array): number;
+    sortedGet(rootPtr: number, key: Uint8Array): SortedSlot | null;
+    sortedGetByIndex(rootPtr: number, rank: number): SortedSlot;
+    sortedRank(rootPtr: number, key: Uint8Array): number;
+    writeKey(key: Uint8Array): Slot;
+    sortedNewEntry(key: Uint8Array): SortedEntry;
+    sortedPut(nodePtr: number, key: Uint8Array): SortedInsertResult;
+    sortedRemove(nodePtr: number, key: Uint8Array): SortedRemoveResult;
+    sortedGrowRoot(result: SortedInsertResult): number;
+    sortedTargetSlot(kvPos: number, target: SortedMapGetTarget): SlotPointer;
 }
 export {};