xitdb 0.12.0 → 0.14.0

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
@@ -27,8 +32,8 @@ export declare class Header {
     static readonly LENGTH = 12;
     constructor(hashId: number, hashSize: number, version: number, tag: Tag, magicNumber: Uint8Array);
     toBytes(): Uint8Array;
-    static read(core: Core): Promise<Header>;
-    write(core: Core): Promise<void>;
+    static read(core: Core): Header;
+    write(core: Core): void;
     validate(): void;
     withTag(tag: Tag): Header;
 }
@@ -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,30 +70,91 @@ 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): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export type HashMapGetTarget = HashMapGetKVPair | HashMapGetKey | HashMapGetValue;
 export declare class HashMapGetKVPair {
@@ -108,96 +172,136 @@ export declare class HashMapGetValue {
     readonly kind = "value";
     constructor(hash: Uint8Array);
 }
-export type ContextFunction = (cursor: any) => Promise<void>;
+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";
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class ArrayListGet implements PathPartBase {
     index: number;
     readonly kind = "ArrayListGet";
     constructor(index: number);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class ArrayListAppend implements PathPartBase {
     readonly kind = "ArrayListAppend";
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class ArrayListSlice implements PathPartBase {
     size: number;
     readonly kind = "ArrayListSlice";
     constructor(size: number);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListInit implements PathPartBase {
     readonly kind = "LinkedArrayListInit";
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListGet implements PathPartBase {
     index: number;
     readonly kind = "LinkedArrayListGet";
     constructor(index: number);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListAppend implements PathPartBase {
     readonly kind = "LinkedArrayListAppend";
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListSlice implements PathPartBase {
     offset: number;
     size: number;
     readonly kind = "LinkedArrayListSlice";
     constructor(offset: number, size: number);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListConcat implements PathPartBase {
     list: Slot;
     readonly kind = "LinkedArrayListConcat";
     constructor(list: Slot);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListInsert implements PathPartBase {
     index: number;
     readonly kind = "LinkedArrayListInsert";
     constructor(index: number);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class LinkedArrayListRemove implements PathPartBase {
     index: number;
     readonly kind = "LinkedArrayListRemove";
     constructor(index: number);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class HashMapInit implements PathPartBase {
     counted: boolean;
     set: boolean;
     readonly kind = "HashMapInit";
     constructor(counted?: boolean, set?: boolean);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class HashMapGet implements PathPartBase {
     target: HashMapGetTarget;
     readonly kind = "HashMapGet";
     constructor(target: HashMapGetTarget);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class HashMapRemove implements PathPartBase {
     hash: Uint8Array;
     readonly kind = "HashMapRemove";
     constructor(hash: Uint8Array);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    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";
     constructor(data: WriteableData | null);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 export declare class Context implements PathPartBase {
     fn: ContextFunction;
     readonly kind = "Context";
     constructor(fn: ContextFunction);
-    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
 }
 declare class HashMapGetResult {
     slotPtr: SlotPointer;
@@ -209,38 +313,58 @@ 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;
     header: Header;
     txStart: number | null;
-    private constructor();
-    static create(core: Core, hasher: Hasher): Promise<Database>;
+    constructor(core: Core, hasher: Hasher);
     rootCursor(): WriteCursor;
-    freeze(): Promise<void>;
-    compact(targetCore: Core): Promise<Database>;
-    truncate(): Promise<void>;
+    freeze(): void;
+    compact(targetCore: Core): Database;
+    truncate(): void;
     checkHashBytes(hash: Uint8Array): Uint8Array;
     checkHash(target: HashMapGetTarget): Uint8Array;
-    readSlotPointer(writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
-    readMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, writeMode: WriteMode, isTopLevel: boolean, target: HashMapGetTarget): Promise<HashMapGetResult>;
-    removeMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, isTopLevel: boolean): Promise<Slot>;
-    readArrayListSlotAppend(header: ArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): Promise<ArrayListAppendResult>;
-    readArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): Promise<SlotPointer>;
-    readArrayListSlice(header: ArrayListHeader, size: number): Promise<ArrayListHeader>;
-    readLinkedArrayListSlotAppend(header: LinkedArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): Promise<LinkedArrayListAppendResult>;
-    private static blockLeafCount;
-    private static slotLeafCount;
-    private static keyAndIndexForLinkedArrayList;
-    readLinkedArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): Promise<LinkedArrayListSlotPointer>;
-    readLinkedArrayListBlocks(indexPos: number, key: number, shift: number, blocks: LinkedArrayListBlockInfo[]): Promise<void>;
-    private populateArray;
-    readLinkedArrayListSlice(header: LinkedArrayListHeader, offset: number, size: number): Promise<LinkedArrayListHeader>;
-    readLinkedArrayListConcat(headerA: LinkedArrayListHeader, headerB: LinkedArrayListHeader): Promise<LinkedArrayListHeader>;
+    readSlotPointer(writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
+    readMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, writeMode: WriteMode, isTopLevel: boolean, target: HashMapGetTarget): HashMapGetResult;
+    removeMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, isTopLevel: boolean): Slot;
+    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;
+    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 {};