@codai/cbd/dist/engines/TimeSeriesStorageEngine.d.ts

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

/**
 * Time-Series Storage Engine - InfluxDB-compatible time-series database
 * Part of CBD Universal Database Phase 3
 */
import { EventEmitter } from 'events';
export interface TimeSeriesPoint {
    measurement: string;
    tags: Record<string, string>;
    fields: Record<string, number | string | boolean>;
    timestamp: Date;
}
export interface TimeSeriesQuery {
    measurement: string;
    startTime?: Date;
    endTime?: Date;
    tags?: Record<string, string>;
    fields?: string[];
    aggregation?: 'mean' | 'sum' | 'count' | 'min' | 'max' | 'first' | 'last';
    groupBy?: string[];
    interval?: string;
    limit?: number;
    offset?: number;
}
export interface TimeSeriesResult {
    measurement: string;
    points: TimeSeriesPoint[];
    totalCount: number;
    executionTime: number;
}
export interface TimeSeriesStats {
    totalPoints: number;
    measurements: Map<string, number>;
    timeRange: {
        earliest: Date | null;
        latest: Date | null;
    };
    retention: {
        policies: RetentionPolicy[];
        totalSize: number;
    };
    queryLatency: {
        p50: number;
        p95: number;
        p99: number;
    };
}
export interface RetentionPolicy {
    name: string;
    duration: string;
    measurement?: string;
    isDefault: boolean;
}
export interface MeasurementInfo {
    name: string;
    pointCount: number;
    firstPoint: Date | null;
    lastPoint: Date | null;
    tags: Set<string>;
    fields: Map<string, 'number' | 'string' | 'boolean'>;
}
export declare class TimeSeriesStorageEngine extends EventEmitter {
    private points;
    private measurements;
    private retentionPolicies;
    private timeIndex;
    private tagIndex;
    private latencyMetrics;
    constructor();
    /**
     * Write time-series points
     */
    writePoints(points: TimeSeriesPoint[]): Promise<void>;
    /**
     * Query time-series data
     */
    query(query: TimeSeriesQuery): Promise<TimeSeriesResult>;
    /**
     * Apply data retention policies
     */
    private cleanupOldData;
    /**
     * Delete data points
     */
    deletePoints(measurement: string, startTime?: Date, endTime?: Date, tags?: Record<string, string>): Promise<number>;
    /**
     * Get database statistics
     */
    getStats(): Promise<TimeSeriesStats>;
    /**
     * Apply aggregation to points
     */
    private applyAggregation;
    /**
     * Parse duration string to milliseconds
     */
    private parseDuration;
    /**
     * Get time key for indexing (rounded to minute)
     */
    private getTimeKey;
    /**
     * Get interval key for time-based grouping
     */
    private getIntervalKey;
    /**
     * Rebuild indexes for a measurement
     */
    private rebuildIndexes;
    /**
     * Track query latency
     */
    private trackLatency;
    /**
     * Calculate percentile from sorted array
     */
    private getPercentile;
    /**
     * Estimate storage size in bytes
     */
    private estimateStorageSize;
    /**
     * Add or update retention policy
     */
    addRetentionPolicy(policy: RetentionPolicy): void;
    /**
     * Remove retention policy
     */
    removeRetentionPolicy(name: string): boolean;
    /**
     * List all measurements
     */
    getMeasurements(): MeasurementInfo[];
    /**
     * Drop a measurement (delete all data)
     */
    dropMeasurement(measurement: string): Promise<boolean>;
}
//# sourceMappingURL=TimeSeriesStorageEngine.d.ts.map