dataply 0.0.26-alpha.4 → 0.0.26-alpha.6

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

@@ -1,5 +1,6 @@
 import { type DataplyOptions, type DataplyMetadata } from '../types';
 import { type IHookall } from 'hookall';
+import { Ryoiki } from 'ryoiki';
 import { PageFileSystem } from './PageFileSystem';
 import { RowTableEngine } from './RowTableEngine';
 import { TextCodec } from '../utils/TextCodec';
@@ -47,7 +48,23 @@ export declare class DataplyAPI {
     private txIdCounter;
     /** Promise-chain mutex for serializing write operations */
     private writeQueue;
+    /** Lock manager. Used for managing transactions */
+    protected readonly latcher: Ryoiki;
     constructor(file: string, options: DataplyOptions);
+    /**
+     * Acquire a read lock on the given page ID and execute the given function.
+     * @param pageId Page ID to acquire a read lock on
+     * @param fn Function to execute while holding the read lock
+     * @returns The result of the given function
+     */
+    latchReadLock<T>(pageId: number, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Acquire a write lock on the given page ID and execute the given function.
+     * @param pageId Page ID to acquire a write lock on
+     * @param fn Function to execute while holding the write lock
+     * @returns The result of the given function
+     */
+    latchWriteLock<T>(pageId: number, fn: () => Promise<T>): Promise<T>;
     /**
      * Verifies if the page file is a valid Dataply file.
      * The metadata page must be located at the beginning of the Dataply file.

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

@@ -1,5 +1,6 @@
 import type { IndexPage, MetadataPage, DataplyOptions } from '../types';
 import type { Transaction } from './transaction/Transaction';
+import { AsyncMVCCTransaction } from 'mvcc-api';
 import { PageManagerFactory } from './Page';
 import { WALManager } from './WALManager';
 import { PageMVCCStrategy } from './PageMVCCStrategy';
@@ -17,6 +18,7 @@ export declare class PageFileSystem {
     protected readonly walManager: WALManager | null;
     protected readonly pageManagerFactory: PageManagerFactory;
     protected readonly pageStrategy: PageMVCCStrategy;
+    protected readonly rootTransaction: AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>;
     protected readonly logger: Logger;
     /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
     private lockPromise;
@@ -39,6 +41,10 @@ export declare class PageFileSystem {
      * Returns the page strategy for transaction use.
      */
     getPageStrategy(): PageMVCCStrategy;
+    /**
+     * Returns the root MVCC transaction.
+     */
+    getRootTransaction(): AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>;
     /**
      * Updates the bitmap status for a specific page.
      * @param pageId The ID of the page to update
@@ -134,16 +140,10 @@ export declare class PageFileSystem {
      * @param tx Transaction
      */
     setFreePage(pageId: number, tx: Transaction): Promise<void>;
-    /**
-     * WAL에 커밋합니다.
-     * @param dirtyPages 변경된 페이지들
-     */
-    commitToWAL(dirtyPages: Map<number, Uint8Array>): Promise<void>;
     /**
      * 체크포인트를 수행합니다.
-     * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
-     * 2. DB 파일 물리적 동기화 (Sync/fsync)
-     * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+     * 1. DB 파일 물리적 동기화 (Sync/fsync)
+     * 2. WAL 로그 파일 비우기 (Clear/Truncate)
      */
     checkpoint(): Promise<void>;
     /**

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

@@ -1,23 +1,20 @@
+import { AsyncMVCCStrategy } from 'mvcc-api';
 /**
  * 페이지 수준 MVCC Strategy.
  * mvcc-api의 AsyncMVCCStrategy를 상속하여 디스크 I/O를 담당합니다.
+ * 캐시 및 버퍼 관리는 mvcc-api의 AsyncMVCCTransaction이 담당합니다.
  *
  * 키: 페이지 ID (number)
  * 값: 페이지 데이터 (Uint8Array)
  */
-export declare class PageMVCCStrategy {
+export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Array> {
     private readonly fileHandle;
     private readonly pageSize;
-    /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
-    private readonly cache;
-    /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
-    private readonly dirtyPages;
     /** 파일 크기 (논리적) */
     private fileSize;
-    constructor(fileHandle: number, pageSize: number, cacheCapacity: number);
+    constructor(fileHandle: number, pageSize: number);
     /**
      * 디스크에서 페이지를 읽습니다.
-     * 캐시에 있으면 캐시에서 반환합니다.
      * @param pageId 페이지 ID
      * @returns 페이지 데이터
      */
@@ -29,22 +26,7 @@ export declare class PageMVCCStrategy {
      */
     write(pageId: number, data: Uint8Array): Promise<void>;
     /**
-     * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
-     * WAL 체크포인트 시점에 호출되어야 합니다.
-     */
-    flush(): Promise<void>;
-    /**
-     * 지정된 페이지들만 디스크에 기록합니다.
-     * WAL 없이 트랜잭션 커밋 시, 해당 트랜잭션의 dirty pages만 선택적으로 flush합니다.
-     * @param pages 기록할 페이지 맵 (PageID -> PageData)
-     */
-    flushPages(pages: Map<number, Uint8Array>): Promise<void>;
-    /**
-     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
-     */
-    sync(): Promise<void>;
-    /**
-     * 페이지 삭제 (실제로는 캐시에서만 제거)
+     * 페이지 삭제.
      * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
      * @param pageId 페이지 ID
      */
@@ -56,13 +38,13 @@ export declare class PageMVCCStrategy {
      */
     exists(pageId: number): Promise<boolean>;
     /**
-     * 현재 파일 크기 반환
+     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
      */
-    getFileSize(): number;
+    sync(): Promise<void>;
     /**
-     * 캐시 초기화
+     * 현재 파일 크기 반환
      */
-    clearCache(): void;
+    getFileSize(): number;
     private _readFromDisk;
     private _writeToDisk;
 }

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

@@ -1,5 +1,5 @@
 import type { DataplyMetadata, DataplyOptions } from '../types';
-import { BPTreeAsync } from 'serializable-bptree';
+import { BPTreePureAsync } from 'serializable-bptree';
 import { RowIdentifierStrategy } from './RowIndexStrategy';
 import { PageFileSystem } from './PageFileSystem';
 import { Row } from './Row';
@@ -12,7 +12,7 @@ export declare class RowTableEngine {
     protected readonly pfs: PageFileSystem;
     protected readonly txContext: TransactionContext;
     protected readonly options: Required<DataplyOptions>;
-    protected readonly bptree: BPTreeAsync<number, number>;
+    protected readonly bptree: BPTreePureAsync<number, number>;
     protected readonly strategy: RowIdentifierStrategy;
     protected readonly order: number;
     protected readonly factory: PageManagerFactory;
@@ -27,13 +27,6 @@ export declare class RowTableEngine {
     private readonly logger;
     private initialized;
     constructor(pfs: PageFileSystem, txContext: TransactionContext, options: Required<DataplyOptions>, logger: Logger);
-    /**
-     * Retrieves the BPTree transaction associated with the given transaction.
-     * If it doesn't exist, it creates a new one and registers commit/rollback hooks.
-     * @param tx Dataply transaction
-     * @returns BPTree transaction
-     */
-    private getBPTreeTransaction;
     /**
      * Initializes the B+ Tree.
      */

package/dist/types/core/transaction/Transaction.d.ts

@@ -1,11 +1,12 @@
 import type { PageFileSystem } from '../PageFileSystem';
-import { BPTreeAsyncTransaction } from 'serializable-bptree';
+import type { AsyncMVCCTransaction } from 'mvcc-api';
+import type { PageMVCCStrategy } from '../PageMVCCStrategy';
 import { LockManager } from './LockManager';
 import { TransactionContext } from './TxContext';
-import { PageMVCCStrategy } from '../PageMVCCStrategy';
 /**
  * Transaction class.
  * Manages the lifecycle and resources of a database transaction.
+ * Internally wraps a nested AsyncMVCCTransaction for snapshot isolation.
  */
 export declare class Transaction {
     readonly context: TransactionContext;
@@ -17,47 +18,28 @@ export declare class Transaction {
     private heldLocks;
     /** Held page locks (PageID -> LockID) */
     private pageLocks;
-    /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
-    private dirtyPages;
-    /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
-    private undoPages;
-    /** BPTree Transaction instance */
-    private bptreeTx?;
-    /** Whether the BPTree transaction is dirty */
-    private bptreeDirty;
     /** List of callbacks to execute on commit */
     private commitHooks;
-    /** Page MVCC Strategy for disk access */
-    private readonly pageStrategy;
+    /** Nested MVCC Transaction for snapshot isolation (lazy init) */
+    private mvccTx;
+    /** Root MVCC Transaction reference */
+    private readonly rootTx;
     /** Release function for global write lock, set by DataplyAPI */
     private _writeLockRelease;
     /**
      * @param id Transaction ID
      * @param context Transaction context
-     * @param pageStrategy Page MVCC Strategy for disk I/O
+     * @param rootTx Root MVCC Transaction
      * @param lockManager LockManager instance
      * @param pfs Page File System
      */
-    constructor(id: number, context: TransactionContext, pageStrategy: PageMVCCStrategy, lockManager: LockManager, pfs: PageFileSystem);
+    constructor(id: number, context: TransactionContext, rootTx: AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>, lockManager: LockManager, pfs: PageFileSystem);
     /**
-     * Sets the BPTree transaction.
-     * @param tx BPTree transaction
+     * Lazily initializes the nested MVCC transaction.
+     * This ensures the snapshot is taken at the time of first access,
+     * picking up the latest committed root version.
      */
-    __setBPTreeTransaction(tx: BPTreeAsyncTransaction<number, number>): void;
-    /**
-     * Returns the BPTree transaction.
-     * @returns BPTree transaction
-     */
-    __getBPTreeTransaction(): BPTreeAsyncTransaction<number, number> | undefined;
-    /**
-     * Marks the BPTree transaction as dirty.
-     */
-    __markBPTreeDirty(): void;
-    /**
-     * Returns whether the BPTree transaction is dirty.
-     * @returns True if dirty
-     */
-    __isBPTreeDirty(): boolean;
+    private ensureMvccTx;
     /**
      * Registers a commit hook.
      * @param hook Function to execute
@@ -73,13 +55,13 @@ export declare class Transaction {
      */
     __hasWriteLockRelease(): boolean;
     /**
-     * Reads a page. Uses dirty buffer if available, otherwise disk.
+     * Reads a page through the MVCC transaction.
      * @param pageId Page ID
      * @returns Page data
      */
     readPage(pageId: number): Promise<Uint8Array>;
     /**
-     * Writes a page to the transaction buffer.
+     * Writes a page through the MVCC transaction.
      * @param pageId Page ID
      * @param data Page data
      */
@@ -97,10 +79,6 @@ export declare class Transaction {
      * Rolls back the transaction.
      */
     rollback(): Promise<void>;
-    /**
-     * Returns the dirty pages map.
-     */
-    __getDirtyPages(): Map<number, Uint8Array>;
     /**
      * Releases all locks.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.4",
+  "version": "0.0.26-alpha.6",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -47,8 +47,8 @@
   "dependencies": {
     "cache-entanglement": "^1.7.1",
     "hookall": "^2.2.0",
-    "mvcc-api": "^1.3.6",
+    "mvcc-api": "^1.3.7",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^8.4.1"
+    "serializable-bptree": "^9.0.0"
   }
-}
+}