semantic-ds-toolkit/dist/src/optimization/connection-pool.d.ts

Performance-first semantic layer for modern data stacks - Stable Column Anchors & intelligent inference

import { EventEmitter } from 'events';
interface ConnectionConfig {
    host: string;
    port: number;
    database: string;
    username: string;
    password: string;
    connectionTimeout: number;
    queryTimeout: number;
    ssl?: boolean;
    schema?: string;
}
interface PoolConfig {
    minConnections: number;
    maxConnections: number;
    acquireTimeout: number;
    idleTimeout: number;
    maxLifetime: number;
    healthCheckInterval: number;
    reconnectInterval: number;
    maxReconnectAttempts: number;
}
interface Connection {
    id: string;
    config: ConnectionConfig;
    isConnected: boolean;
    isIdle: boolean;
    lastUsed: number;
    createdAt: number;
    queryCount: number;
    errorCount: number;
    nativeConnection?: any;
}
interface QueryResult {
    rows: any[];
    rowCount: number;
    executionTime: number;
    columns: string[];
}
interface PoolStats {
    totalConnections: number;
    idleConnections: number;
    activeConnections: number;
    queuedRequests: number;
    totalQueries: number;
    averageQueryTime: number;
    errorRate: number;
}
interface QueryOptions {
    timeout?: number;
    priority?: 'high' | 'medium' | 'low';
    retryAttempts?: number;
    cacheable?: boolean;
}
export declare class ConnectionPool extends EventEmitter {
    private config;
    private connectionConfigs;
    private connections;
    private availableConnections;
    private requestQueue;
    private stats;
    private healthCheckTimer?;
    private isShuttingDown;
    constructor(connectionConfigs: ConnectionConfig | ConnectionConfig[], poolConfig?: Partial<PoolConfig>);
    private initialize;
    private createConnection;
    private selectConnectionConfig;
    private simulateConnection;
    acquireConnection(timeout?: number): Promise<Connection>;
    private getAvailableConnection;
    private isConnectionHealthy;
    private markConnectionBusy;
    private queueConnectionRequest;
    releaseConnection(connection: Connection): void;
    private processQueuedRequests;
    private removeConnection;
    private closeNativeConnection;
    private ensureMinimumConnections;
    executeQuery(sql: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
    private runQuery;
    private generateMockRows;
    private extractColumns;
    private updateQueryStats;
    executeBatch(queries: Array<{
        sql: string;
        params?: any[];
    }>): Promise<QueryResult[]>;
    private startHealthCheck;
    private performHealthCheck;
    getStats(): PoolStats;
    shutdown(): Promise<void>;
}
export declare class WarehouseConnectionPool extends ConnectionPool {
    private queryCache;
    constructor(connectionConfigs: ConnectionConfig | ConnectionConfig[], poolConfig?: Partial<PoolConfig>);
    executeQuery(sql: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
    private getCacheKey;
    private getCachedResult;
    private cacheResult;
    private cleanupCache;
}
export declare function createOptimizedPool(type: 'oltp' | 'olap' | 'mixed', connectionConfigs: ConnectionConfig | ConnectionConfig[]): ConnectionPool;
export declare function createGlobalPools(configs: {
    oltp?: ConnectionConfig | ConnectionConfig[];
    olap?: ConnectionConfig | ConnectionConfig[];
    mixed?: ConnectionConfig | ConnectionConfig[];
}): {
    oltpPool?: ConnectionPool;
    olapPool?: WarehouseConnectionPool;
    mixedPool?: ConnectionPool;
};
export {};
//# sourceMappingURL=connection-pool.d.ts.map