@codai/cbd/dist/universal/UniversalStorageEngine.d.ts

Codai Better Database - High-Performance Vector Memory System with HPKV-inspired architecture and MCP server

/**
 * CBD Universal Storage Engine
 * Adaptive storage supporting all database paradigms with optimal performance
 *
 * Phase 1: Foundation storage engine with adaptive layout and multi-paradigm support
 */
import { EventEmitter } from 'events';
import { UniversalRecord, QueryContext, QueryResult } from './UniversalDataModel.js';
/**
 * Storage engine configuration
 */
export interface StorageEngineConfig {
    dataPath: string;
    maxMemoryUsage: number;
    cacheSize: number;
    flushInterval: number;
    defaultLayout: 'row' | 'column' | 'hybrid';
    compressionEnabled: boolean;
    compressionAlgorithm: 'snappy' | 'lz4' | 'zstd';
    vectorIndexType: 'hnsw' | 'ivf' | 'lsh';
    sqlPageSize: number;
    documentMaxSize: number;
    nodeId?: string;
    clusterEnabled?: boolean;
}
/**
 * Storage statistics and monitoring
 */
export interface StorageStats {
    totalRecords: number;
    relationalRecords: number;
    documentRecords: number;
    graphNodes: number;
    graphEdges: number;
    vectorRecords: number;
    timeSeriesRecords: number;
    keyValueRecords: number;
    totalSizeBytes: number;
    compressedSizeBytes: number;
    compressionRatio: number;
    averageReadLatency: number;
    averageWriteLatency: number;
    cacheHitRate: number;
    indexEfficiency: number;
    memoryUsageBytes: number;
    diskUsageBytes: number;
    cpuUsagePercent: number;
    uptime: number;
    lastHealthCheck: Date;
    errorRate: number;
}
/**
 * Universal Storage Engine - core engine supporting all paradigms
 */
export declare class UniversalStorageEngine extends EventEmitter {
    private config;
    private initialized;
    private stats;
    private memoryCache;
    private persistentStorage;
    private indexManager;
    private compressionEngine;
    private performanceTracker;
    private lastFlushTime;
    constructor(config: StorageEngineConfig);
    /**
     * Initialize the storage engine
     */
    initialize(): Promise<void>;
    /**
     * Store a universal record
     */
    store(record: UniversalRecord, context?: QueryContext): Promise<string>;
    /**
     * Retrieve a record by ID
     */
    get(recordId: string, context?: QueryContext): Promise<UniversalRecord | null>;
    /**
     * Query records using multi-paradigm query
     */
    query(query: UniversalQuery, context?: QueryContext): Promise<QueryResult>;
    /**
     * Update a record
     */
    update(recordId: string, updates: Partial<UniversalRecord>, context?: QueryContext): Promise<boolean>;
    /**
     * Delete a record
     */
    delete(recordId: string, context?: QueryContext): Promise<boolean>;
    /**
     * Get storage statistics
     */
    getStats(): Promise<StorageStats>;
    /**
     * Optimize storage performance
     */
    optimize(): Promise<void>;
    /**
     * Shutdown the storage engine gracefully
     */
    shutdown(): Promise<void>;
    private ensureInitialized;
    private createInitialStats;
    private setupMaintenanceTasks;
    private loadHotData;
    private verifyStorageIntegrity;
    private determineStorageStrategy;
    private updateStatsAfterWrite;
    private updateStatsAfterRead;
    private updateStatsAfterQuery;
    private updateStatsAfterDelete;
    private calculateMemoryUsage;
    private estimateRecordSize;
    private addToCache;
    private evictLeastRecentlyUsed;
    private optimizeMemoryCache;
    private cleanupCache;
    private flush;
    private applySecurityFiltering;
    private optimizeQuery;
    private createExecutionPlan;
    private executeQuery;
    private postProcessResults;
    private hasDeletePermission;
    /**
     * Get time since last flush in milliseconds
     */
    getTimeSinceLastFlush(): number;
    private recalculateStats;
}
interface UniversalQuery {
    paradigm: 'sql' | 'document' | 'graph' | 'vector' | 'timeseries' | 'keyvalue' | 'hybrid';
    query: string | object;
    parameters?: Record<string, any>;
    limit?: number;
    offset?: number;
    orderBy?: Array<{
        field: string;
        direction: 'asc' | 'desc';
    }>;
    filters?: Array<{
        field: string;
        operator: string;
        value: any;
    }>;
}
export interface ExecutionPlan {
    strategy: string;
    indexesUsed: string[];
    recordsScanned: number;
    cacheUtilized: boolean;
    estimatedCost: number;
}
export {};
//# sourceMappingURL=UniversalStorageEngine.d.ts.map