@yydb/light-db 0.0.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/indexes/BPlusTree.d.ts

@@ -0,0 +1,181 @@
+/**
+ * LightDB B+ 树实现
+ * 用于主键索引，支持 O(log n) 的插入、查找、删除和范围查询
+ */
+import type { Comparator, IndexKey } from "./types";
+/**
+ * B+ 树实现
+ * 提供高效的键值存储和范围查询能力
+ */
+export declare class BPlusTree<K extends IndexKey, V> {
+    private root;
+    private readonly order;
+    private readonly comparator;
+    private size;
+    private firstLeaf;
+    private lastLeaf;
+    /**
+     * 创建 B+ 树实例
+     * @param order B+ 树阶数，默认 64
+     * @param comparator 键比较器
+     */
+    constructor(order?: number, comparator?: Comparator<K>);
+    /**
+     * 获取树中键值对数量
+     */
+    get Size(): number;
+    /**
+     * 检查树是否为空
+     */
+    isEmpty(): boolean;
+    /**
+     * 插入键值对
+     * @param key 键
+     * @param value 值
+     * @returns 如果键已存在，返回旧值；否则返回 undefined
+     */
+    insert(key: K, value: V): V | undefined;
+    /**
+     * 查找键对应的值
+     * @param key 键
+     * @returns 值，如果不存在返回 undefined
+     */
+    find(key: K): V | undefined;
+    /**
+     * 检查键是否存在
+     * @param key 键
+     */
+    has(key: K): boolean;
+    /**
+     * 删除键值对
+     * @param key 键
+     * @returns 被删除的值，如果不存在返回 undefined
+     */
+    delete(key: K): V | undefined;
+    /**
+     * 更新键对应的值
+     * @param key 键
+     * @param value 新值
+     * @returns 是否更新成功
+     */
+    update(key: K, value: V): boolean;
+    /**
+     * 范围查询
+     * @param start 起始键（包含）
+     * @param end 结束键（包含）
+     * @param includeStart 是否包含起始键
+     * @param includeEnd 是否包含结束键
+     * @returns 键值对数组
+     */
+    range(
+        start?: K,
+        end?: K,
+        includeStart?: boolean,
+        includeEnd?: boolean,
+    ): Array<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * 获取所有键（有序）
+     */
+    keys(): K[];
+    /**
+     * 获取所有值（按键顺序）
+     */
+    values(): V[];
+    /**
+     * 获取所有键值对（有序）
+     */
+    entries(): Array<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * 清空树
+     */
+    clear(): void;
+    /**
+     * 获取最小键
+     */
+    minKey(): K | undefined;
+    /**
+     * 获取最大键
+     */
+    maxKey(): K | undefined;
+    /**
+     * 获取第一个键值对
+     */
+    first():
+        | {
+              key: K;
+              value: V;
+          }
+        | undefined;
+    /**
+     * 获取最后一个键值对
+     */
+    last():
+        | {
+              key: K;
+              value: V;
+          }
+        | undefined;
+    /**
+     * 遍历树
+     * @param callback 回调函数
+     */
+    forEach(callback: (key: K, value: V) => void): void;
+    /**
+     * 创建迭代器
+     */
+    [Symbol.iterator](): Generator<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * 查找键所在的叶子节点
+     */
+    private findLeafNode;
+    /**
+     * 在叶子节点中插入键值对
+     */
+    private insertIntoLeaf;
+    /**
+     * 分裂叶子节点
+     */
+    private splitLeaf;
+    /**
+     * 分裂内部节点
+     */
+    private splitInternal;
+    /**
+     * 查找或创建父节点
+     */
+    private findOrCreateParent;
+    /**
+     * 查找父节点
+     */
+    private findParent;
+    /**
+     * 移除空叶子节点
+     */
+    private removeLeafNode;
+    /**
+     * 二分查找
+     */
+    private binarySearch;
+    /**
+     * 查找键在数组中的索引
+     */
+    private findKeyIndex;
+    /**
+     * 查找第一个大于等于目标键的索引
+     */
+    private findFirstGreaterOrEqual;
+    /**
+     * 更新已存在键的值
+     */
+    private updateValue;
+}
+//# sourceMappingURL=BPlusTree.d.ts.map

package/dist/indexes/BPlusTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BPlusTree.d.ts","sourceRoot":"","sources":["../../src/indexes/BPlusTree.ts"],"names":[],"mappings":"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"}

package/dist/indexes/BPlusTree.js

@@ -0,0 +1,528 @@
+"use strict";
+/**
+ * LightDB B+ 树实现
+ * 用于主键索引，支持 O(log n) 的插入、查找、删除和范围查询
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BPlusTree = void 0;
+const errors_1 = require("./errors");
+/**
+ * 默认 B+ 树阶数（每个节点最多存储的键数量）
+ */
+const DEFAULT_ORDER = 64;
+/**
+ * B+ 树叶子节点
+ */
+class BPlusTreeLeafNode {
+    constructor() {
+        this.keys = [];
+        this.values = [];
+        this.next = null;
+        this.prev = null;
+    }
+    isLeaf() {
+        return true;
+    }
+}
+/**
+ * B+ 树内部节点
+ */
+class BPlusTreeInternalNode {
+    constructor() {
+        this.keys = [];
+        this.children = [];
+    }
+    isLeaf() {
+        return false;
+    }
+}
+/**
+ * 默认比较器
+ * 支持字符串和数值类型的比较
+ */
+function defaultComparator(a, b) {
+    if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+    }
+    const strA = String(a);
+    const strB = String(b);
+    if (strA < strB) return -1;
+    if (strA > strB) return 1;
+    return 0;
+}
+/**
+ * B+ 树实现
+ * 提供高效的键值存储和范围查询能力
+ */
+class BPlusTree {
+    /**
+     * 创建 B+ 树实例
+     * @param order B+ 树阶数，默认 64
+     * @param comparator 键比较器
+     */
+    constructor(order = DEFAULT_ORDER, comparator) {
+        this.size = 0;
+        this.firstLeaf = null;
+        this.lastLeaf = null;
+        if (order < 3) {
+            throw new errors_1.IndexOperationError("B+ tree order must be at least 3", "constructor");
+        }
+        this.order = order;
+        this.comparator = comparator ?? defaultComparator;
+        this.root = new BPlusTreeLeafNode();
+        this.firstLeaf = this.root;
+        this.lastLeaf = this.root;
+    }
+    /**
+     * 获取树中键值对数量
+     */
+    get Size() {
+        return this.size;
+    }
+    /**
+     * 检查树是否为空
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * 插入键值对
+     * @param key 键
+     * @param value 值
+     * @returns 如果键已存在，返回旧值；否则返回 undefined
+     */
+    insert(key, value) {
+        const existingValue = this.find(key);
+        if (existingValue !== undefined) {
+            this.updateValue(key, value);
+            return existingValue;
+        }
+        const leaf = this.findLeafNode(key);
+        this.insertIntoLeaf(leaf, key, value);
+        this.size++;
+        if (leaf.keys.length > this.order) {
+            this.splitLeaf(leaf);
+        }
+        return undefined;
+    }
+    /**
+     * 查找键对应的值
+     * @param key 键
+     * @returns 值，如果不存在返回 undefined
+     */
+    find(key) {
+        const leaf = this.findLeafNode(key);
+        const index = this.binarySearch(leaf.keys, key);
+        if (index >= 0 && index < leaf.keys.length) {
+            const cmp = this.comparator(leaf.keys[index], key);
+            if (cmp === 0) {
+                return leaf.values[index];
+            }
+        }
+        for (let i = 0; i < leaf.keys.length; i++) {
+            if (this.comparator(leaf.keys[i], key) === 0) {
+                return leaf.values[i];
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 检查键是否存在
+     * @param key 键
+     */
+    has(key) {
+        return this.find(key) !== undefined;
+    }
+    /**
+     * 删除键值对
+     * @param key 键
+     * @returns 被删除的值，如果不存在返回 undefined
+     */
+    delete(key) {
+        const leaf = this.findLeafNode(key);
+        const index = this.findKeyIndex(leaf.keys, key);
+        if (index === -1) {
+            return undefined;
+        }
+        const value = leaf.values[index];
+        leaf.keys.splice(index, 1);
+        leaf.values.splice(index, 1);
+        this.size--;
+        if (leaf.keys.length === 0 && leaf !== this.root) {
+            this.removeLeafNode(leaf);
+        }
+        return value;
+    }
+    /**
+     * 更新键对应的值
+     * @param key 键
+     * @param value 新值
+     * @returns 是否更新成功
+     */
+    update(key, value) {
+        const leaf = this.findLeafNode(key);
+        const index = this.findKeyIndex(leaf.keys, key);
+        if (index === -1) {
+            return false;
+        }
+        leaf.values[index] = value;
+        return true;
+    }
+    /**
+     * 范围查询
+     * @param start 起始键（包含）
+     * @param end 结束键（包含）
+     * @param includeStart 是否包含起始键
+     * @param includeEnd 是否包含结束键
+     * @returns 键值对数组
+     */
+    range(start, end, includeStart = true, includeEnd = true) {
+        const result = [];
+        if (this.size === 0) {
+            return result;
+        }
+        let startLeaf;
+        let startIndex;
+        if (start !== undefined) {
+            startLeaf = this.findLeafNode(start);
+            startIndex = this.findFirstGreaterOrEqual(startLeaf.keys, start);
+        } else {
+            startLeaf = this.firstLeaf;
+            startIndex = 0;
+        }
+        let currentLeaf = startLeaf;
+        let currentIndex = startIndex;
+        while (currentLeaf !== null) {
+            for (let i = currentIndex; i < currentLeaf.keys.length; i++) {
+                const key = currentLeaf.keys[i];
+                if (start !== undefined) {
+                    const cmp = this.comparator(key, start);
+                    if (cmp < 0 || (cmp === 0 && !includeStart)) {
+                        continue;
+                    }
+                }
+                if (end !== undefined) {
+                    const cmp = this.comparator(key, end);
+                    if (cmp > 0 || (cmp === 0 && !includeEnd)) {
+                        return result;
+                    }
+                }
+                result.push({ key, value: currentLeaf.values[i] });
+            }
+            currentLeaf = currentLeaf.next;
+            currentIndex = 0;
+        }
+        return result;
+    }
+    /**
+     * 获取所有键（有序）
+     */
+    keys() {
+        const result = [];
+        let current = this.firstLeaf;
+        while (current !== null) {
+            result.push(...current.keys);
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * 获取所有值（按键顺序）
+     */
+    values() {
+        const result = [];
+        let current = this.firstLeaf;
+        while (current !== null) {
+            result.push(...current.values);
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * 获取所有键值对（有序）
+     */
+    entries() {
+        const result = [];
+        let current = this.firstLeaf;
+        while (current !== null) {
+            for (let i = 0; i < current.keys.length; i++) {
+                result.push({ key: current.keys[i], value: current.values[i] });
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * 清空树
+     */
+    clear() {
+        this.root = new BPlusTreeLeafNode();
+        this.firstLeaf = this.root;
+        this.lastLeaf = this.root;
+        this.size = 0;
+    }
+    /**
+     * 获取最小键
+     */
+    minKey() {
+        if (this.size === 0) {
+            return undefined;
+        }
+        return this.firstLeaf.keys[0];
+    }
+    /**
+     * 获取最大键
+     */
+    maxKey() {
+        if (this.size === 0) {
+            return undefined;
+        }
+        return this.lastLeaf.keys[this.lastLeaf.keys.length - 1];
+    }
+    /**
+     * 获取第一个键值对
+     */
+    first() {
+        if (this.size === 0) {
+            return undefined;
+        }
+        return {
+            key: this.firstLeaf.keys[0],
+            value: this.firstLeaf.values[0],
+        };
+    }
+    /**
+     * 获取最后一个键值对
+     */
+    last() {
+        if (this.size === 0) {
+            return undefined;
+        }
+        const lastIndex = this.lastLeaf.keys.length - 1;
+        return {
+            key: this.lastLeaf.keys[lastIndex],
+            value: this.lastLeaf.values[lastIndex],
+        };
+    }
+    /**
+     * 遍历树
+     * @param callback 回调函数
+     */
+    forEach(callback) {
+        let current = this.firstLeaf;
+        while (current !== null) {
+            for (let i = 0; i < current.keys.length; i++) {
+                callback(current.keys[i], current.values[i]);
+            }
+            current = current.next;
+        }
+    }
+    /**
+     * 创建迭代器
+     */
+    *[Symbol.iterator]() {
+        let current = this.firstLeaf;
+        while (current !== null) {
+            for (let i = 0; i < current.keys.length; i++) {
+                yield { key: current.keys[i], value: current.values[i] };
+            }
+            current = current.next;
+        }
+    }
+    /**
+     * 查找键所在的叶子节点
+     */
+    findLeafNode(key) {
+        let node = this.root;
+        while (!node.isLeaf()) {
+            const internalNode = node;
+            let i = 0;
+            while (i < internalNode.keys.length && this.comparator(key, internalNode.keys[i]) >= 0) {
+                i++;
+            }
+            node = internalNode.children[i];
+        }
+        return node;
+    }
+    /**
+     * 在叶子节点中插入键值对
+     */
+    insertIntoLeaf(leaf, key, value) {
+        let i = 0;
+        while (i < leaf.keys.length && this.comparator(key, leaf.keys[i]) > 0) {
+            i++;
+        }
+        leaf.keys.splice(i, 0, key);
+        leaf.values.splice(i, 0, value);
+    }
+    /**
+     * 分裂叶子节点
+     */
+    splitLeaf(leaf) {
+        const mid = Math.floor(leaf.keys.length / 2);
+        const newLeaf = new BPlusTreeLeafNode();
+        newLeaf.keys = leaf.keys.splice(mid);
+        newLeaf.values = leaf.values.splice(mid);
+        newLeaf.next = leaf.next;
+        newLeaf.prev = leaf;
+        if (leaf.next) {
+            leaf.next.prev = newLeaf;
+        }
+        leaf.next = newLeaf;
+        if (leaf === this.lastLeaf) {
+            this.lastLeaf = newLeaf;
+        }
+        const parent = this.findOrCreateParent(leaf);
+        const insertIndex = parent.children.indexOf(leaf) + 1;
+        const promoteKey = newLeaf.keys[0];
+        parent.keys.splice(insertIndex - 1, 0, promoteKey);
+        parent.children.splice(insertIndex, 0, newLeaf);
+        if (parent.keys.length >= this.order) {
+            this.splitInternal(parent);
+        }
+    }
+    /**
+     * 分裂内部节点
+     */
+    splitInternal(node) {
+        const mid = Math.floor(node.keys.length / 2);
+        const newNode = new BPlusTreeInternalNode();
+        const promoteKey = node.keys[mid];
+        newNode.keys = node.keys.splice(mid + 1);
+        node.keys.pop();
+        newNode.children = node.children.splice(mid + 1);
+        if (node === this.root) {
+            const newRoot = new BPlusTreeInternalNode();
+            newRoot.keys.push(promoteKey);
+            newRoot.children.push(node, newNode);
+            this.root = newRoot;
+        } else {
+            const parent = this.findOrCreateParent(node);
+            const insertIndex = parent.children.indexOf(node) + 1;
+            parent.keys.splice(insertIndex - 1, 0, promoteKey);
+            parent.children.splice(insertIndex, 0, newNode);
+            if (parent.keys.length >= this.order) {
+                this.splitInternal(parent);
+            }
+        }
+    }
+    /**
+     * 查找或创建父节点
+     */
+    findOrCreateParent(node) {
+        if (node === this.root) {
+            const newRoot = new BPlusTreeInternalNode();
+            newRoot.children.push(this.root);
+            this.root = newRoot;
+            return newRoot;
+        }
+        return this.findParent(this.root, node);
+    }
+    /**
+     * 查找父节点
+     */
+    findParent(current, target) {
+        if (current.isLeaf()) {
+            return null;
+        }
+        const internalNode = current;
+        for (const child of internalNode.children) {
+            if (child === target) {
+                return internalNode;
+            }
+            if (!child.isLeaf()) {
+                const found = this.findParent(child, target);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 移除空叶子节点
+     */
+    removeLeafNode(leaf) {
+        if (leaf.prev) {
+            leaf.prev.next = leaf.next;
+        } else {
+            this.firstLeaf = leaf.next;
+        }
+        if (leaf.next) {
+            leaf.next.prev = leaf.prev;
+        } else {
+            this.lastLeaf = leaf.prev;
+        }
+        if (leaf === this.root) {
+            this.root = new BPlusTreeLeafNode();
+            this.firstLeaf = this.root;
+            this.lastLeaf = this.root;
+            return;
+        }
+        const parent = this.findParent(this.root, leaf);
+        if (parent) {
+            const index = parent.children.indexOf(leaf);
+            if (index !== -1) {
+                parent.children.splice(index, 1);
+                if (index > 0) {
+                    parent.keys.splice(index - 1, 1);
+                } else if (parent.keys.length > 0) {
+                    parent.keys.splice(0, 1);
+                }
+            }
+        }
+    }
+    /**
+     * 二分查找
+     */
+    binarySearch(keys, key) {
+        let left = 0;
+        let right = keys.length - 1;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            const cmp = this.comparator(keys[mid], key);
+            if (cmp === 0) {
+                return mid;
+            } else if (cmp < 0) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return left;
+    }
+    /**
+     * 查找键在数组中的索引
+     */
+    findKeyIndex(keys, key) {
+        for (let i = 0; i < keys.length; i++) {
+            if (this.comparator(keys[i], key) === 0) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * 查找第一个大于等于目标键的索引
+     */
+    findFirstGreaterOrEqual(keys, key) {
+        for (let i = 0; i < keys.length; i++) {
+            if (this.comparator(keys[i], key) >= 0) {
+                return i;
+            }
+        }
+        return keys.length;
+    }
+    /**
+     * 更新已存在键的值
+     */
+    updateValue(key, value) {
+        const leaf = this.findLeafNode(key);
+        const index = this.findKeyIndex(leaf.keys, key);
+        if (index !== -1) {
+            leaf.values[index] = value;
+        }
+    }
+}
+exports.BPlusTree = BPlusTree;
+//# sourceMappingURL=BPlusTree.js.map