@yydb/light-db 0.0.0

package/dist/indexes/SecondaryIndex.d.ts

@@ -0,0 +1,204 @@
+/**
+ * LightDB 二级索引实现
+ * 使用 Map<索引值, Set<主键>> 结构，支持高效的等值查询
+ */
+import type { IndexKey, IndexValue, IndexStats, EqualityCondition } from "./types";
+import { IndexType } from "./types";
+/**
+ * 二级索引配置
+ */
+export interface SecondaryIndexConfig {
+    /** 索引名称 */
+    name: string;
+    /** 字段名 */
+    fieldName: string;
+    /** 是否唯一索引 */
+    unique?: boolean;
+    /** 是否稀疏索引（不索引 null/undefined 值） */
+    sparse?: boolean;
+}
+/**
+ * 二级索引
+ * 使用 Map + Set 结构实现，支持等值查询和范围查询
+ */
+export declare class SecondaryIndex {
+    private readonly index;
+    private readonly config;
+    private keyCount;
+    /**
+     * 创建二级索引实例
+     * @param config 索引配置
+     */
+    constructor(config: SecondaryIndexConfig);
+    /**
+     * 获取索引名称
+     */
+    get Name(): string;
+    /**
+     * 获取字段名
+     */
+    get FieldName(): string;
+    /**
+     * 获取索引类型
+     */
+    get Type(): IndexType.Secondary | IndexType.Unique;
+    /**
+     * 获取是否唯一索引
+     */
+    get IsUnique(): boolean;
+    /**
+     * 获取是否稀疏索引
+     */
+    get IsSparse(): boolean;
+    /**
+     * 获取索引中的键数量
+     */
+    get Size(): number;
+    /**
+     * 获取索引值数量
+     */
+    get ValueCount(): number;
+    /**
+     * 检查索引是否为空
+     */
+    isEmpty(): boolean;
+    /**
+     * 插入索引条目
+     * @param value 索引值
+     * @param primaryKey 主键
+     * @param throwOnDuplicate 如果是唯一索引且值已存在是否抛出异常
+     * @returns 是否插入成功
+     */
+    insert(value: IndexValue, primaryKey: IndexKey, throwOnDuplicate?: boolean): boolean;
+    /**
+     * 删除索引条目
+     * @param value 索引值
+     * @param primaryKey 主键
+     * @returns 是否删除成功
+     */
+    delete(value: IndexValue, primaryKey: IndexKey): boolean;
+    /**
+     * 更新索引条目
+     * @param oldValue 旧索引值
+     * @param newValue 新索引值
+     * @param primaryKey 主键
+     * @param throwOnDuplicate 如果是唯一索引且新值已存在是否抛出异常
+     * @returns 是否更新成功
+     */
+    update(oldValue: IndexValue, newValue: IndexValue, primaryKey: IndexKey, throwOnDuplicate?: boolean): boolean;
+    /**
+     * 等值查询
+     * @param value 索引值
+     * @returns 匹配的主键集合
+     */
+    find(value: IndexValue): Set<IndexKey>;
+    /**
+     * 检查索引值是否存在
+     * @param value 索引值
+     */
+    has(value: IndexValue): boolean;
+    /**
+     * 检查索引值和主键组合是否存在
+     * @param value 索引值
+     * @param primaryKey 主键
+     */
+    hasEntry(value: IndexValue, primaryKey: IndexKey): boolean;
+    /**
+     * 条件查询
+     * @param condition 查询条件
+     * @returns 匹配的主键集合
+     */
+    query(condition: EqualityCondition<IndexValue>): Set<IndexKey>;
+    /**
+     * 范围查询
+     * @param start 起始值
+     * @param end 结束值
+     * @param includeStart 是否包含起始值
+     * @param includeEnd 是否包含结束值
+     * @returns 匹配的主键集合
+     */
+    range(start?: IndexValue, end?: IndexValue, includeStart?: boolean, includeEnd?: boolean): Set<IndexKey>;
+    /**
+     * 获取所有索引值
+     */
+    values(): IndexValue[];
+    /**
+     * 获取所有主键
+     */
+    keys(): IndexKey[];
+    /**
+     * 获取所有条目
+     */
+    entries(): Array<{
+        value: IndexValue;
+        keys: Set<IndexKey>;
+    }>;
+    /**
+     * 清空索引
+     */
+    clear(): void;
+    /**
+     * 获取索引统计信息
+     */
+    getStats(): IndexStats;
+    /**
+     * 批量插入
+     * @param entries 条目数组
+     * @param throwOnDuplicate 如果是唯一索引且值已存在是否抛出异常
+     */
+    insertBatch(
+        entries: Array<{
+            value: IndexValue;
+            primaryKey: IndexKey;
+        }>,
+        throwOnDuplicate?: boolean,
+    ): {
+        success: number;
+        failed: number;
+        errors: Array<{
+            primaryKey: IndexKey;
+            error: string;
+        }>;
+    };
+    /**
+     * 批量删除
+     * @param entries 条目数组
+     */
+    deleteBatch(
+        entries: Array<{
+            value: IndexValue;
+            primaryKey: IndexKey;
+        }>,
+    ): {
+        success: number;
+        failed: number;
+    };
+    /**
+     * 将索引值转换为存储键
+     */
+    private valueToKey;
+    /**
+     * 将存储键转换为索引值
+     */
+    private keyToValue;
+    /**
+     * 比较两个索引值
+     */
+    private compareValues;
+    /**
+     * 获取排序后的条目
+     */
+    private getSortedEntries;
+    /**
+     * 估算内存使用
+     */
+    private estimateMemoryUsage;
+    /**
+     * 验证索引一致性
+     */
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+//# sourceMappingURL=SecondaryIndex.d.ts.map

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

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

package/dist/indexes/SecondaryIndex.js

@@ -0,0 +1,480 @@
+"use strict";
+/**
+ * LightDB 二级索引实现
+ * 使用 Map<索引值, Set<主键>> 结构，支持高效的等值查询
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecondaryIndex = void 0;
+const types_1 = require("./types");
+const errors_1 = require("./errors");
+/**
+ * 二级索引
+ * 使用 Map + Set 结构实现，支持等值查询和范围查询
+ */
+class SecondaryIndex {
+    /**
+     * 创建二级索引实例
+     * @param config 索引配置
+     */
+    constructor(config) {
+        this.keyCount = 0;
+        this.config = {
+            name: config.name,
+            fieldName: config.fieldName,
+            unique: config.unique ?? false,
+            sparse: config.sparse ?? false,
+        };
+        this.index = new Map();
+    }
+    /**
+     * 获取索引名称
+     */
+    get Name() {
+        return this.config.name;
+    }
+    /**
+     * 获取字段名
+     */
+    get FieldName() {
+        return this.config.fieldName;
+    }
+    /**
+     * 获取索引类型
+     */
+    get Type() {
+        return this.config.unique ? types_1.IndexType.Unique : types_1.IndexType.Secondary;
+    }
+    /**
+     * 获取是否唯一索引
+     */
+    get IsUnique() {
+        return this.config.unique;
+    }
+    /**
+     * 获取是否稀疏索引
+     */
+    get IsSparse() {
+        return this.config.sparse;
+    }
+    /**
+     * 获取索引中的键数量
+     */
+    get Size() {
+        return this.keyCount;
+    }
+    /**
+     * 获取索引值数量
+     */
+    get ValueCount() {
+        return this.index.size;
+    }
+    /**
+     * 检查索引是否为空
+     */
+    isEmpty() {
+        return this.keyCount === 0;
+    }
+    /**
+     * 插入索引条目
+     * @param value 索引值
+     * @param primaryKey 主键
+     * @param throwOnDuplicate 如果是唯一索引且值已存在是否抛出异常
+     * @returns 是否插入成功
+     */
+    insert(value, primaryKey, throwOnDuplicate = false) {
+        if (value === null || value === undefined) {
+            if (this.config.sparse) {
+                return true;
+            }
+        }
+        const valueKey = this.valueToKey(value);
+        if (this.config.unique) {
+            const existing = this.index.get(valueKey);
+            if (existing && existing.size > 0) {
+                if (throwOnDuplicate) {
+                    throw new errors_1.DuplicateKeyError(this.config.name, value);
+                }
+                return false;
+            }
+        }
+        let keySet = this.index.get(valueKey);
+        if (!keySet) {
+            keySet = new Set();
+            this.index.set(valueKey, keySet);
+        }
+        if (keySet.has(primaryKey)) {
+            return false;
+        }
+        keySet.add(primaryKey);
+        this.keyCount++;
+        return true;
+    }
+    /**
+     * 删除索引条目
+     * @param value 索引值
+     * @param primaryKey 主键
+     * @returns 是否删除成功
+     */
+    delete(value, primaryKey) {
+        if (value === null || value === undefined) {
+            if (this.config.sparse) {
+                return true;
+            }
+        }
+        const valueKey = this.valueToKey(value);
+        const keySet = this.index.get(valueKey);
+        if (!keySet) {
+            return false;
+        }
+        const deleted = keySet.delete(primaryKey);
+        if (deleted) {
+            this.keyCount--;
+        }
+        if (keySet.size === 0) {
+            this.index.delete(valueKey);
+        }
+        return deleted;
+    }
+    /**
+     * 更新索引条目
+     * @param oldValue 旧索引值
+     * @param newValue 新索引值
+     * @param primaryKey 主键
+     * @param throwOnDuplicate 如果是唯一索引且新值已存在是否抛出异常
+     * @returns 是否更新成功
+     */
+    update(oldValue, newValue, primaryKey, throwOnDuplicate = false) {
+        const oldKey = this.valueToKey(oldValue);
+        const newKey = this.valueToKey(newValue);
+        if (oldKey === newKey) {
+            return true;
+        }
+        if (this.config.unique) {
+            const existing = this.index.get(newKey);
+            if (existing && existing.size > 0) {
+                if (throwOnDuplicate) {
+                    throw new errors_1.DuplicateKeyError(this.config.name, newValue);
+                }
+                return false;
+            }
+        }
+        this.delete(oldValue, primaryKey);
+        this.insert(newValue, primaryKey, throwOnDuplicate);
+        return true;
+    }
+    /**
+     * 等值查询
+     * @param value 索引值
+     * @returns 匹配的主键集合
+     */
+    find(value) {
+        const valueKey = this.valueToKey(value);
+        const keySet = this.index.get(valueKey);
+        return keySet ? new Set(keySet) : new Set();
+    }
+    /**
+     * 检查索引值是否存在
+     * @param value 索引值
+     */
+    has(value) {
+        const valueKey = this.valueToKey(value);
+        const keySet = this.index.get(valueKey);
+        return keySet !== undefined && keySet.size > 0;
+    }
+    /**
+     * 检查索引值和主键组合是否存在
+     * @param value 索引值
+     * @param primaryKey 主键
+     */
+    hasEntry(value, primaryKey) {
+        const valueKey = this.valueToKey(value);
+        const keySet = this.index.get(valueKey);
+        return keySet !== undefined && keySet.has(primaryKey);
+    }
+    /**
+     * 条件查询
+     * @param condition 查询条件
+     * @returns 匹配的主键集合
+     */
+    query(condition) {
+        if (condition.$eq !== undefined) {
+            return this.find(condition.$eq);
+        }
+        const result = new Set();
+        if (condition.$in !== undefined) {
+            for (const value of condition.$in) {
+                const keys = this.find(value);
+                for (const key of keys) {
+                    result.add(key);
+                }
+            }
+        }
+        if (condition.$ne !== undefined) {
+            const excludeKeys = this.find(condition.$ne);
+            for (const [_, keySet] of this.index) {
+                for (const key of keySet) {
+                    if (!excludeKeys.has(key)) {
+                        result.add(key);
+                    }
+                }
+            }
+        }
+        if (condition.$nin !== undefined) {
+            const excludeKeys = new Set();
+            for (const value of condition.$nin) {
+                const keys = this.find(value);
+                for (const key of keys) {
+                    excludeKeys.add(key);
+                }
+            }
+            for (const [_, keySet] of this.index) {
+                for (const key of keySet) {
+                    if (!excludeKeys.has(key)) {
+                        result.add(key);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 范围查询
+     * @param start 起始值
+     * @param end 结束值
+     * @param includeStart 是否包含起始值
+     * @param includeEnd 是否包含结束值
+     * @returns 匹配的主键集合
+     */
+    range(start, end, includeStart = true, includeEnd = true) {
+        const result = new Set();
+        const sortedEntries = this.getSortedEntries();
+        for (const { value, keys } of sortedEntries) {
+            if (start !== undefined) {
+                const cmp = this.compareValues(value, start);
+                if (cmp < 0 || (cmp === 0 && !includeStart)) {
+                    continue;
+                }
+            }
+            if (end !== undefined) {
+                const cmp = this.compareValues(value, end);
+                if (cmp > 0 || (cmp === 0 && !includeEnd)) {
+                    break;
+                }
+            }
+            for (const key of keys) {
+                result.add(key);
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取所有索引值
+     */
+    values() {
+        const result = [];
+        for (const key of this.index.keys()) {
+            result.push(this.keyToValue(key));
+        }
+        return result;
+    }
+    /**
+     * 获取所有主键
+     */
+    keys() {
+        const result = [];
+        for (const keySet of this.index.values()) {
+            for (const key of keySet) {
+                result.push(key);
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取所有条目
+     */
+    entries() {
+        const result = [];
+        for (const [key, keySet] of this.index) {
+            result.push({
+                value: this.keyToValue(key),
+                keys: new Set(keySet),
+            });
+        }
+        return result;
+    }
+    /**
+     * 清空索引
+     */
+    clear() {
+        this.index.clear();
+        this.keyCount = 0;
+    }
+    /**
+     * 获取索引统计信息
+     */
+    getStats() {
+        const valueCount = this.index.size;
+        const memoryUsage = this.estimateMemoryUsage();
+        return {
+            name: this.config.name,
+            type: this.Type,
+            fieldName: this.config.fieldName,
+            keyCount: this.keyCount,
+            entryCount: valueCount,
+            unique: this.config.unique,
+            memoryUsage,
+        };
+    }
+    /**
+     * 批量插入
+     * @param entries 条目数组
+     * @param throwOnDuplicate 如果是唯一索引且值已存在是否抛出异常
+     */
+    insertBatch(entries, throwOnDuplicate = false) {
+        let success = 0;
+        let failed = 0;
+        const errors = [];
+        for (const { value, primaryKey } of entries) {
+            try {
+                if (this.insert(value, primaryKey, throwOnDuplicate)) {
+                    success++;
+                } else {
+                    failed++;
+                    errors.push({ primaryKey, error: "Duplicate or existing entry" });
+                }
+            } catch (error) {
+                failed++;
+                errors.push({
+                    primaryKey,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+            }
+        }
+        return { success, failed, errors };
+    }
+    /**
+     * 批量删除
+     * @param entries 条目数组
+     */
+    deleteBatch(entries) {
+        let success = 0;
+        let failed = 0;
+        for (const { value, primaryKey } of entries) {
+            if (this.delete(value, primaryKey)) {
+                success++;
+            } else {
+                failed++;
+            }
+        }
+        return { success, failed };
+    }
+    /**
+     * 将索引值转换为存储键
+     */
+    valueToKey(value) {
+        if (value === null) {
+            return "\x00null";
+        }
+        if (value === undefined) {
+            return "\x00undefined";
+        }
+        if (typeof value === "number") {
+            return `\x01num:${value}`;
+        }
+        if (typeof value === "boolean") {
+            return `\x02bool:${value}`;
+        }
+        return `\x03str:${value}`;
+    }
+    /**
+     * 将存储键转换为索引值
+     */
+    keyToValue(key) {
+        if (key === "\x00null") {
+            return null;
+        }
+        if (key === "\x00undefined") {
+            return null;
+        }
+        if (key.startsWith("\x01num:")) {
+            return parseFloat(key.slice(6));
+        }
+        if (key.startsWith("\x02bool:")) {
+            return key.slice(7) === "true";
+        }
+        if (key.startsWith("\x03str:")) {
+            return key.slice(6);
+        }
+        return key;
+    }
+    /**
+     * 比较两个索引值
+     */
+    compareValues(a, b) {
+        if (a === null && b === null) return 0;
+        if (a === null) return -1;
+        if (b === null) return 1;
+        if (a === undefined && b === undefined) return 0;
+        if (a === undefined) return -1;
+        if (b === undefined) return 1;
+        const typeA = typeof a;
+        const typeB = typeof b;
+        if (typeA !== typeB) {
+            return typeA.localeCompare(typeB);
+        }
+        if (typeA === "number") {
+            return a - b;
+        }
+        if (typeA === "boolean") {
+            return (a ? 1 : 0) - (b ? 1 : 0);
+        }
+        const strA = String(a);
+        const strB = String(b);
+        if (strA < strB) return -1;
+        if (strA > strB) return 1;
+        return 0;
+    }
+    /**
+     * 获取排序后的条目
+     */
+    getSortedEntries() {
+        const entries = this.entries();
+        entries.sort((a, b) => this.compareValues(a.value, b.value));
+        return entries;
+    }
+    /**
+     * 估算内存使用
+     */
+    estimateMemoryUsage() {
+        const avgValueSize = 32;
+        const avgKeySize = 16;
+        const setOverhead = 64;
+        const mapOverhead = 64;
+        return this.index.size * (avgValueSize + mapOverhead) + this.keyCount * (avgKeySize + setOverhead);
+    }
+    /**
+     * 验证索引一致性
+     */
+    validate() {
+        const errors = [];
+        let countedKeys = 0;
+        for (const [valueKey, keySet] of this.index) {
+            if (keySet.size === 0) {
+                errors.push(`Empty key set for value: ${valueKey}`);
+            }
+            if (this.config.unique && keySet.size > 1) {
+                errors.push(`Unique index has multiple keys for value: ${valueKey}`);
+            }
+            countedKeys += keySet.size;
+        }
+        if (countedKeys !== this.keyCount) {
+            errors.push(`Key count mismatch: expected ${this.keyCount}, found ${countedKeys}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+exports.SecondaryIndex = SecondaryIndex;
+//# sourceMappingURL=SecondaryIndex.js.map