dataply 0.0.20-alpha.2 → 0.0.20-alpha.3

package/dist/cjs/index.js

@@ -7427,9 +7427,6 @@ var WALManager = class {
       promises.push(writePage(pageId, data));
     }
     await Promise.all(promises);
-    if (restoredPages.size > 0) {
-      await this.clear();
-    }
   }
   /**
    * WAL에 페이지 데이터를 기록합니다 (Phase 1: Prepare).
@@ -7590,6 +7587,8 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
   }
   /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
   cache;
+  /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
+  dirtyPages = /* @__PURE__ */ new Map();
   /** 파일 크기 (논리적) */
   fileSize;
   /**
@@ -7599,6 +7598,12 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
    * @returns 페이지 데이터
    */
   async read(pageId) {
+    const dirty = this.dirtyPages.get(pageId);
+    if (dirty) {
+      const copy = new Uint8Array(this.pageSize);
+      copy.set(dirty);
+      return copy;
+    }
     const cached = this.cache.get(pageId);
     if (cached) {
       const copy = new Uint8Array(this.pageSize);
@@ -7626,21 +7631,49 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
     if (pageStartPos + this.pageSize > 512 * 1024 * 1024) {
       throw new Error(`[Safety Limit] File write exceeds 512MB limit at position ${pageStartPos}`);
     }
-    await this._writeToDisk(data, pageStartPos);
-    const cacheCopy = new Uint8Array(this.pageSize);
-    cacheCopy.set(data);
-    this.cache.set(pageId, cacheCopy);
+    const dataCopy = new Uint8Array(this.pageSize);
+    dataCopy.set(data);
+    this.dirtyPages.set(pageId, dataCopy);
+    this.cache.set(pageId, dataCopy);
     const endPosition = pageStartPos + this.pageSize;
     if (endPosition > this.fileSize) {
       this.fileSize = endPosition;
     }
   }
+  /**
+   * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
+   * WAL 체크포인트 시점에 호출되어야 합니다.
+   */
+  async flush() {
+    if (this.dirtyPages.size === 0) {
+      return;
+    }
+    const sortedPageIds = Array.from(this.dirtyPages.keys()).sort((a, b) => a - b);
+    for (const pageId of sortedPageIds) {
+      const data = this.dirtyPages.get(pageId);
+      const position = pageId * this.pageSize;
+      await this._writeToDisk(data, position);
+    }
+    this.dirtyPages.clear();
+  }
+  /**
+   * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
+   */
+  async sync() {
+    return new Promise((resolve, reject) => {
+      import_node_fs2.default.fsync(this.fileHandle, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  }
   /**
    * 페이지 삭제 (실제로는 캐시에서만 제거)
    * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
    * @param pageId 페이지 ID
    */
   async delete(pageId) {
+    this.dirtyPages.delete(pageId);
     this.cache.delete(pageId);
   }
   /**
@@ -7649,6 +7682,9 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
    * @returns 존재하면 true
    */
   async exists(pageId) {
+    if (this.dirtyPages.has(pageId)) {
+      return true;
+    }
     const pageStartPos = pageId * this.pageSize;
     return pageStartPos < this.fileSize;
   }
@@ -7700,11 +7736,13 @@ var PageFileSystem = class {
     this.walManager = walPath ? new WALManager(walPath, pageSize) : null;
     this.pageManagerFactory = new PageManagerFactory();
     this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize, pageCacheCapacity);
+    this.lock = new Ryoiki3();
   }
   pageFactory = new PageManagerFactory();
   walManager;
   pageManagerFactory;
   pageStrategy;
+  lock;
   /**
    * Initializes the page file system.
    * Performs WAL recovery if necessary.
@@ -7714,8 +7752,18 @@ var PageFileSystem = class {
       await this.walManager.recover(async (pageId, data) => {
         await this.pageStrategy.write(pageId, data);
       });
+      await this.checkpoint();
     }
   }
+  async lockCheckpoint(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      await fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
+  }
   /**
    * Returns the page strategy for transaction use.
    */
@@ -8013,15 +8061,30 @@ var PageFileSystem = class {
   async commitToWAL(dirtyPages) {
     if (this.walManager) {
       await this.walManager.prepareCommit(dirtyPages);
-      await this.walManager.finalizeCommit(false);
+      await this.walManager.finalizeCommit(true);
     }
   }
+  /**
+   * 체크포인트를 수행합니다.
+   * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
+   * 2. DB 파일 물리적 동기화 (Sync/fsync)
+   * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+   */
+  async checkpoint() {
+    return this.lockCheckpoint(async () => {
+      await this.pageStrategy.flush();
+      await this.pageStrategy.sync();
+      if (this.walManager) {
+        await this.walManager.clear();
+      }
+    });
+  }
   /**
    * Closes the page file system.
    */
   async close() {
+    await this.checkpoint();
     if (this.walManager) {
-      await this.walManager.clear();
       this.walManager.close();
     }
   }
@@ -8842,27 +8905,29 @@ var Transaction = class {
    * Commits the transaction.
    */
   async commit() {
-    await this.context.run(this, async () => {
-      for (const hook of this.commitHooks) {
-        await hook();
+    return this.pfs.lockCheckpoint(async () => {
+      await this.context.run(this, async () => {
+        for (const hook of this.commitHooks) {
+          await hook();
+        }
+      });
+      if (this.pfs.wal && this.dirtyPages.size > 0) {
+        await this.pfs.wal.prepareCommit(this.dirtyPages);
+        await this.pfs.wal.writeCommitMarker();
       }
-    });
-    if (this.pfs.wal && this.dirtyPages.size > 0) {
-      await this.pfs.wal.prepareCommit(this.dirtyPages);
-      await this.pfs.wal.writeCommitMarker();
-    }
-    for (const [pageId, data] of this.dirtyPages) {
-      await this.pageStrategy.write(pageId, data);
-    }
-    if (this.pfs.wal) {
-      this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
-      if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
-        await this.pfs.wal.clear();
+      for (const [pageId, data] of this.dirtyPages) {
+        await this.pageStrategy.write(pageId, data);
       }
-    }
-    this.dirtyPages.clear();
-    this.undoPages.clear();
-    this.releaseAllLocks();
+      if (this.pfs.wal) {
+        this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
+        if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
+          await this.pfs.checkpoint();
+        }
+      }
+      this.dirtyPages.clear();
+      this.undoPages.clear();
+      this.releaseAllLocks();
+    });
   }
   /**
    * Rolls back the transaction.

package/dist/types/core/PageFileSystem.d.ts

@@ -1,4 +1,5 @@
 import type { IndexPage, MetadataPage, DataplyOptions } from '../types';
+import { Ryoiki } from 'ryoiki';
 import type { Transaction } from './transaction/Transaction';
 import { PageManagerFactory } from './Page';
 import { WALManager } from './WALManager';
@@ -16,6 +17,7 @@ export declare class PageFileSystem {
     protected readonly walManager: WALManager | null;
     protected readonly pageManagerFactory: PageManagerFactory;
     protected readonly pageStrategy: PageMVCCStrategy;
+    protected readonly lock: Ryoiki;
     /**
      * @param pageCacheCapacity 페이지 캐시 크기
      * @param options 데이터플라이 옵션
@@ -26,6 +28,7 @@ export declare class PageFileSystem {
      * Performs WAL recovery if necessary.
      */
     init(): Promise<void>;
+    lockCheckpoint(fn: () => Promise<void>): Promise<void>;
     /**
      * Returns the page strategy for transaction use.
      */
@@ -130,6 +133,13 @@ export declare class PageFileSystem {
      * @param dirtyPages 변경된 페이지들
      */
     commitToWAL(dirtyPages: Map<number, Uint8Array>): Promise<void>;
+    /**
+     * 체크포인트를 수행합니다.
+     * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
+     * 2. DB 파일 물리적 동기화 (Sync/fsync)
+     * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+     */
+    checkpoint(): Promise<void>;
     /**
      * Closes the page file system.
      */

package/dist/types/core/PageMVCCStrategy.d.ts

@@ -11,6 +11,8 @@ export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Arr
     private readonly pageSize;
     /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
     private readonly cache;
+    /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
+    private readonly dirtyPages;
     /** 파일 크기 (논리적) */
     private fileSize;
     constructor(fileHandle: number, pageSize: number, cacheCapacity: number);
@@ -27,6 +29,15 @@ export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Arr
      * @param data 페이지 데이터
      */
     write(pageId: number, data: Uint8Array): Promise<void>;
+    /**
+     * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
+     * WAL 체크포인트 시점에 호출되어야 합니다.
+     */
+    flush(): Promise<void>;
+    /**
+     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
+     */
+    sync(): Promise<void>;
     /**
      * 페이지 삭제 (실제로는 캐시에서만 제거)
      * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.20-alpha.2",
+  "version": "0.0.20-alpha.3",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",