xitdb 0.13.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
@@ -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 {};