@yydb/light-db 0.0.0

package/dist/indexes/types.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * LightDB 索引引擎类型定义
+ * 包含所有索引相关的接口、类型和结构体定义
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BPlusTreeNodeType = exports.IndexType = void 0;
+/**
+ * 索引类型枚举
+ */
+var IndexType;
+(function (IndexType) {
+    /** 主键索引（B+树） */
+    IndexType["Primary"] = "primary";
+    /** 二级索引（Map + Set） */
+    IndexType["Secondary"] = "secondary";
+    /** 唯一索引 */
+    IndexType["Unique"] = "unique";
+})(IndexType || (exports.IndexType = IndexType = {}));
+/**
+ * B+ 树节点类型
+ */
+var BPlusTreeNodeType;
+(function (BPlusTreeNodeType) {
+    /** 内部节点 */
+    BPlusTreeNodeType["Internal"] = "internal";
+    /** 叶子节点 */
+    BPlusTreeNodeType["Leaf"] = "leaf";
+})(BPlusTreeNodeType || (exports.BPlusTreeNodeType = BPlusTreeNodeType = {}));
+//# sourceMappingURL=types.js.map

package/dist/indexes/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/indexes/types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA+CH;;GAEG;AACH,IAAY,SAOX;AAPD,WAAY,SAAS;IACjB,gBAAgB;IAChB,gCAAmB,CAAA;IACnB,sBAAsB;IACtB,oCAAuB,CAAA;IACvB,WAAW;IACX,8BAAiB,CAAA;AACrB,CAAC,EAPW,SAAS,yBAAT,SAAS,QAOpB;AAwED;;GAEG;AACH,IAAY,iBAKX;AALD,WAAY,iBAAiB;IACzB,WAAW;IACX,0CAAqB,CAAA;IACrB,WAAW;IACX,kCAAa,CAAA;AACjB,CAAC,EALW,iBAAiB,iCAAjB,iBAAiB,QAK5B"}

package/dist/performance/BatchWALWriter.d.ts

@@ -0,0 +1,185 @@
+/**
+ * 异步批量写入器
+ * 将多个写操作的 WAL 记录暂存于内存队列，定时或队列满时一次性写入
+ */
+import { BatchWriteOptions, BatchWriteStats, BatchFlushResult } from "./types";
+/**
+ * WAL 记录接口
+ */
+export interface WalRecordEntry {
+    /** 日志序列号 */
+    lsn: bigint;
+    /** 事务 ID */
+    transactionId: bigint;
+    /** 操作类型 */
+    operationType: number;
+    /** 键 */
+    key: string;
+    /** 值 */
+    value: Buffer | null;
+}
+/**
+ * 异步批量 WAL 写入器
+ * 支持合并写入、定时刷新和灵活的 fsync 策略
+ */
+export declare class BatchWalWriter {
+    private filePath;
+    private handle;
+    private queue;
+    private queueCapacity;
+    private batchSize;
+    private flushIntervalMs;
+    private fsyncStrategy;
+    private fsyncBatchSize;
+    private fsyncIntervalMs;
+    private flushTimer;
+    private fsyncTimer;
+    private currentOffset;
+    private writeCountSinceFsync;
+    private lastFlushTime;
+    private lastFsyncTime;
+    private totalWritten;
+    private isFlushing;
+    private pendingFlush;
+    private closed;
+    /**
+     * 创建批量 WAL 写入器
+     * @param filePath 文件路径
+     * @param options 配置选项
+     */
+    constructor(filePath: string, options?: BatchWriteOptions);
+    /**
+     * 打开文件
+     */
+    open(): Promise<void>;
+    /**
+     * 启动定时器
+     */
+    private startTimers;
+    /**
+     * 停止定时器
+     */
+    private stopTimers;
+    /**
+     * 序列化 WAL 记录
+     */
+    private serializeRecord;
+    /**
+     * 计算校验和
+     */
+    private calculateChecksum;
+    /**
+     * 获取 CRC32 表
+     */
+    private crc32Table;
+    private getCrc32Table;
+    /**
+     * 添加记录到队列
+     * @param record WAL 记录
+     */
+    append(record: WalRecordEntry): Promise<void>;
+    /**
+     * 批量添加记录
+     * @param records WAL 记录数组
+     */
+    appendMany(records: WalRecordEntry[]): Promise<void>;
+    /**
+     * 刷新队列到磁盘
+     */
+    flush(): Promise<BatchFlushResult>;
+    /**
+     * 同步到磁盘
+     */
+    fsync(): Promise<void>;
+    /**
+     * 获取统计信息
+     */
+    getStats(): BatchWriteStats;
+    /**
+     * 获取当前偏移量
+     */
+    getCurrentOffset(): bigint;
+    /**
+     * 获取文件路径
+     */
+    getFilePath(): string;
+    /**
+     * 清空队列
+     */
+    clearQueue(): void;
+    /**
+     * 关闭写入器
+     */
+    close(): Promise<void>;
+    /**
+     * 清空文件
+     */
+    clear(): Promise<void>;
+}
+/**
+ * 批量写入管理器
+ * 提供更高层的批量写入接口
+ */
+export declare class BatchWriteManager {
+    private writers;
+    private defaultOptions;
+    /**
+     * 创建批量写入管理器
+     * @param defaultOptions 默认配置
+     */
+    constructor(defaultOptions?: BatchWriteOptions);
+    /**
+     * 获取或创建写入器
+     * @param name 写入器名称
+     * @param filePath 文件路径
+     * @param options 配置选项
+     */
+    getWriter(name: string, filePath: string, options?: BatchWriteOptions): Promise<BatchWalWriter>;
+    /**
+     * 写入记录
+     * @param name 写入器名称
+     * @param record WAL 记录
+     */
+    append(name: string, record: WalRecordEntry): Promise<void>;
+    /**
+     * 刷新指定写入器
+     * @param name 写入器名称
+     */
+    flush(name: string): Promise<BatchFlushResult>;
+    /**
+     * 刷新所有写入器
+     */
+    flushAll(): Promise<Map<string, BatchFlushResult>>;
+    /**
+     * 同步指定写入器
+     * @param name 写入器名称
+     */
+    fsync(name: string): Promise<void>;
+    /**
+     * 同步所有写入器
+     */
+    fsyncAll(): Promise<void>;
+    /**
+     * 关闭指定写入器
+     * @param name 写入器名称
+     */
+    closeWriter(name: string): Promise<void>;
+    /**
+     * 关闭所有写入器
+     */
+    closeAll(): Promise<void>;
+    /**
+     * 获取所有写入器名称
+     */
+    getWriterNames(): string[];
+    /**
+     * 获取写入器统计信息
+     * @param name 写入器名称
+     */
+    getStats(name: string): BatchWriteStats | undefined;
+    /**
+     * 获取所有写入器统计信息
+     */
+    getAllStats(): Map<string, BatchWriteStats>;
+}
+//# sourceMappingURL=BatchWalWriter.d.ts.map

package/dist/performance/BatchWALWriter.d.ts.map

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

package/dist/performance/BatchWALWriter.js

@@ -0,0 +1,490 @@
+"use strict";
+/**
+ * 异步批量写入器
+ * 将多个写操作的 WAL 记录暂存于内存队列，定时或队列满时一次性写入
+ */
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __setModuleDefault =
+    (this && this.__setModuleDefault) ||
+    (Object.create
+        ? function (o, v) {
+              Object.defineProperty(o, "default", { enumerable: true, value: v });
+          }
+        : function (o, v) {
+              o["default"] = v;
+          });
+var __importStar =
+    (this && this.__importStar) ||
+    (function () {
+        var ownKeys = function (o) {
+            ownKeys =
+                Object.getOwnPropertyNames ||
+                function (o) {
+                    var ar = [];
+                    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+                    return ar;
+                };
+            return ownKeys(o);
+        };
+        return function (mod) {
+            if (mod && mod.__esModule) return mod;
+            var result = {};
+            if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+            __setModuleDefault(result, mod);
+            return result;
+        };
+    })();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchWriteManager = exports.BatchWalWriter = void 0;
+const fs = __importStar(require("fs/promises"));
+const OptimizedBuffer_1 = require("./OptimizedBuffer");
+/**
+ * 异步批量 WAL 写入器
+ * 支持合并写入、定时刷新和灵活的 fsync 策略
+ */
+class BatchWalWriter {
+    /**
+     * 创建批量 WAL 写入器
+     * @param filePath 文件路径
+     * @param options 配置选项
+     */
+    constructor(filePath, options = {}) {
+        this.handle = null;
+        this.flushTimer = null;
+        this.fsyncTimer = null;
+        /**
+         * 获取 CRC32 表
+         */
+        this.crc32Table = null;
+        this.filePath = filePath;
+        this.queue = [];
+        this.queueCapacity = options.batchSize ? options.batchSize * 2 : 2000;
+        this.batchSize = options.batchSize ?? 100;
+        this.flushIntervalMs = options.flushIntervalMs ?? 100;
+        this.fsyncStrategy = options.fsyncStrategy ?? "batch";
+        this.fsyncBatchSize = options.fsyncBatchSize ?? 1000;
+        this.fsyncIntervalMs = options.fsyncIntervalMs ?? 1000;
+        this.currentOffset = 0n;
+        this.writeCountSinceFsync = 0;
+        this.lastFlushTime = 0;
+        this.lastFsyncTime = 0;
+        this.totalWritten = 0;
+        this.isFlushing = false;
+        this.pendingFlush = false;
+        this.closed = false;
+    }
+    /**
+     * 打开文件
+     */
+    async open() {
+        if (this.handle) {
+            return;
+        }
+        try {
+            const stats = await fs.stat(this.filePath);
+            this.handle = await fs.open(this.filePath, "r+");
+            this.currentOffset = BigInt(stats.size);
+        } catch {
+            this.handle = await fs.open(this.filePath, "w+");
+            this.currentOffset = 0n;
+        }
+        this.startTimers();
+    }
+    /**
+     * 启动定时器
+     */
+    startTimers() {
+        if (this.flushIntervalMs > 0) {
+            this.flushTimer = setInterval(() => {
+                this.flush().catch(() => {});
+            }, this.flushIntervalMs);
+        }
+        if (this.fsyncStrategy === "interval" && this.fsyncIntervalMs > 0) {
+            this.fsyncTimer = setInterval(() => {
+                this.fsync().catch(() => {});
+            }, this.fsyncIntervalMs);
+        }
+    }
+    /**
+     * 停止定时器
+     */
+    stopTimers() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.fsyncTimer) {
+            clearInterval(this.fsyncTimer);
+            this.fsyncTimer = null;
+        }
+    }
+    /**
+     * 序列化 WAL 记录
+     */
+    serializeRecord(record) {
+        const keyLen = Buffer.byteLength(record.key, "utf8");
+        const valueLen = record.value ? record.value.length : 0;
+        const headerSize = 8 + 8 + 1 + 4 + 4;
+        const totalSize = headerSize + keyLen + valueLen + 4;
+        const writer = new OptimizedBuffer_1.OptimizedBufferWriter(totalSize);
+        writer.writeBigUInt64LE(record.lsn);
+        writer.writeBigUInt64LE(record.transactionId);
+        writer.writeUInt8(record.operationType);
+        writer.writeUInt32LE(keyLen);
+        writer.writeUInt32LE(valueLen);
+        writer.writeStringRaw(record.key);
+        if (record.value && valueLen > 0) {
+            writer.writeBuffer(record.value);
+        }
+        const checksum = this.calculateChecksum(writer.data, 0, writer.position);
+        writer.writeUInt32LE(checksum);
+        return writer.data;
+    }
+    /**
+     * 计算校验和
+     */
+    calculateChecksum(buffer, offset, length) {
+        let crc = 0xffffffff;
+        const table = this.getCrc32Table();
+        for (let i = offset; i < offset + length; i++) {
+            const byte = buffer[i];
+            crc = (crc >>> 8) ^ table[(crc ^ byte) & 0xff];
+        }
+        return (crc ^ 0xffffffff) >>> 0;
+    }
+    getCrc32Table() {
+        if (!this.crc32Table) {
+            this.crc32Table = new Uint32Array(256);
+            for (let i = 0; i < 256; i++) {
+                let crc = i;
+                for (let j = 0; j < 8; j++) {
+                    crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+                }
+                this.crc32Table[i] = crc;
+            }
+        }
+        return this.crc32Table;
+    }
+    /**
+     * 添加记录到队列
+     * @param record WAL 记录
+     */
+    async append(record) {
+        if (this.closed) {
+            throw new Error("BatchWALWriter is closed");
+        }
+        const buffer = this.serializeRecord(record);
+        if (this.queue.length >= this.queueCapacity) {
+            await this.flush();
+        }
+        this.queue.push({ record, buffer });
+        if (this.queue.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    /**
+     * 批量添加记录
+     * @param records WAL 记录数组
+     */
+    async appendMany(records) {
+        for (const record of records) {
+            await this.append(record);
+        }
+    }
+    /**
+     * 刷新队列到磁盘
+     */
+    async flush() {
+        if (this.closed) {
+            return {
+                recordsWritten: 0,
+                bytesWritten: 0,
+                durationMs: 0,
+                fsynced: false,
+            };
+        }
+        if (this.isFlushing) {
+            this.pendingFlush = true;
+            return {
+                recordsWritten: 0,
+                bytesWritten: 0,
+                durationMs: 0,
+                fsynced: false,
+            };
+        }
+        if (this.queue.length === 0) {
+            return {
+                recordsWritten: 0,
+                bytesWritten: 0,
+                durationMs: 0,
+                fsynced: false,
+            };
+        }
+        this.isFlushing = true;
+        const startTime = Date.now();
+        try {
+            if (!this.handle) {
+                await this.open();
+            }
+            const entries = this.queue.splice(0, this.queue.length);
+            const concatenator = new OptimizedBuffer_1.BufferConcatenator();
+            for (const entry of entries) {
+                concatenator.append(entry.buffer);
+            }
+            const buffer = concatenator.concat();
+            const bytesWritten = buffer.length;
+            await this.handle.write(buffer, 0, buffer.length, Number(this.currentOffset));
+            this.currentOffset += BigInt(bytesWritten);
+            this.totalWritten += entries.length;
+            this.writeCountSinceFsync += entries.length;
+            this.lastFlushTime = Date.now();
+            let fsynced = false;
+            if (this.fsyncStrategy === "always") {
+                await this.fsync();
+                fsynced = true;
+            } else if (this.fsyncStrategy === "batch" && this.writeCountSinceFsync >= this.fsyncBatchSize) {
+                await this.fsync();
+                fsynced = true;
+            }
+            const durationMs = Date.now() - startTime;
+            return {
+                recordsWritten: entries.length,
+                bytesWritten,
+                durationMs,
+                fsynced,
+            };
+        } finally {
+            this.isFlushing = false;
+            if (this.pendingFlush) {
+                this.pendingFlush = false;
+                this.flush().catch(() => {});
+            }
+        }
+    }
+    /**
+     * 同步到磁盘
+     */
+    async fsync() {
+        if (this.closed || !this.handle) {
+            return;
+        }
+        await this.handle.sync();
+        this.writeCountSinceFsync = 0;
+        this.lastFsyncTime = Date.now();
+    }
+    /**
+     * 获取统计信息
+     */
+    getStats() {
+        return {
+            pendingCount: this.queue.length,
+            writtenCount: this.totalWritten,
+            lastFlushTime: this.lastFlushTime,
+            lastFsyncTime: this.lastFsyncTime,
+            queueCapacity: this.queueCapacity,
+        };
+    }
+    /**
+     * 获取当前偏移量
+     */
+    getCurrentOffset() {
+        return this.currentOffset;
+    }
+    /**
+     * 获取文件路径
+     */
+    getFilePath() {
+        return this.filePath;
+    }
+    /**
+     * 清空队列
+     */
+    clearQueue() {
+        this.queue = [];
+    }
+    /**
+     * 关闭写入器
+     */
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.stopTimers();
+        await this.flush();
+        if (this.fsyncStrategy !== "manual") {
+            await this.fsync();
+        }
+        if (this.handle) {
+            await this.handle.close();
+            this.handle = null;
+        }
+    }
+    /**
+     * 清空文件
+     */
+    async clear() {
+        await this.close();
+        await fs.truncate(this.filePath, 0);
+        this.queue = [];
+        this.currentOffset = 0n;
+        this.writeCountSinceFsync = 0;
+        this.totalWritten = 0;
+        this.closed = false;
+        await this.open();
+    }
+}
+exports.BatchWalWriter = BatchWalWriter;
+/**
+ * 批量写入管理器
+ * 提供更高层的批量写入接口
+ */
+class BatchWriteManager {
+    /**
+     * 创建批量写入管理器
+     * @param defaultOptions 默认配置
+     */
+    constructor(defaultOptions = {}) {
+        this.writers = new Map();
+        this.defaultOptions = defaultOptions;
+    }
+    /**
+     * 获取或创建写入器
+     * @param name 写入器名称
+     * @param filePath 文件路径
+     * @param options 配置选项
+     */
+    async getWriter(name, filePath, options) {
+        let writer = this.writers.get(name);
+        if (!writer) {
+            writer = new BatchWalWriter(filePath, {
+                ...this.defaultOptions,
+                ...options,
+            });
+            await writer.open();
+            this.writers.set(name, writer);
+        }
+        return writer;
+    }
+    /**
+     * 写入记录
+     * @param name 写入器名称
+     * @param record WAL 记录
+     */
+    async append(name, record) {
+        const writer = this.writers.get(name);
+        if (!writer) {
+            throw new Error(`Writer "${name}" not found`);
+        }
+        await writer.append(record);
+    }
+    /**
+     * 刷新指定写入器
+     * @param name 写入器名称
+     */
+    async flush(name) {
+        const writer = this.writers.get(name);
+        if (!writer) {
+            throw new Error(`Writer "${name}" not found`);
+        }
+        return writer.flush();
+    }
+    /**
+     * 刷新所有写入器
+     */
+    async flushAll() {
+        const results = new Map();
+        for (const [name, writer] of this.writers) {
+            results.set(name, await writer.flush());
+        }
+        return results;
+    }
+    /**
+     * 同步指定写入器
+     * @param name 写入器名称
+     */
+    async fsync(name) {
+        const writer = this.writers.get(name);
+        if (!writer) {
+            throw new Error(`Writer "${name}" not found`);
+        }
+        await writer.fsync();
+    }
+    /**
+     * 同步所有写入器
+     */
+    async fsyncAll() {
+        const promises = [];
+        for (const writer of this.writers.values()) {
+            promises.push(writer.fsync());
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * 关闭指定写入器
+     * @param name 写入器名称
+     */
+    async closeWriter(name) {
+        const writer = this.writers.get(name);
+        if (writer) {
+            await writer.close();
+            this.writers.delete(name);
+        }
+    }
+    /**
+     * 关闭所有写入器
+     */
+    async closeAll() {
+        const promises = [];
+        for (const writer of this.writers.values()) {
+            promises.push(writer.close());
+        }
+        await Promise.all(promises);
+        this.writers.clear();
+    }
+    /**
+     * 获取所有写入器名称
+     */
+    getWriterNames() {
+        return Array.from(this.writers.keys());
+    }
+    /**
+     * 获取写入器统计信息
+     * @param name 写入器名称
+     */
+    getStats(name) {
+        const writer = this.writers.get(name);
+        return writer?.getStats();
+    }
+    /**
+     * 获取所有写入器统计信息
+     */
+    getAllStats() {
+        const stats = new Map();
+        for (const [name, writer] of this.writers) {
+            stats.set(name, writer.getStats());
+        }
+        return stats;
+    }
+}
+exports.BatchWriteManager = BatchWriteManager;
+//# sourceMappingURL=BatchWalWriter.js.map