plugin-postgresql-connector/lib/server/services/QueryExecutor.d.ts

NocoBase plugin for connecting to external PostgreSQL databases

import { PoolClient } from 'pg';
import { ConnectionManager } from './ConnectionManager';
export interface QueryResult {
    rows: any[];
    rowCount: number;
    fields?: Array<{
        name: string;
        dataTypeID: number;
        dataTypeSize: number;
        dataTypeName?: string;
    }>;
    executionTime: number;
    query: string;
    formattedQuery?: string;
}
export interface QueryParameter {
    name: string;
    value: any;
    type?: string;
}
export interface QueryOptions {
    timeout?: number;
    maxRows?: number;
    formatQuery?: boolean;
    includeMetadata?: boolean;
}
export interface SchemaInfo {
    tables: Array<{
        table_name: string;
        table_type: string;
        table_schema: string;
    }>;
    views: Array<{
        view_name: string;
        view_definition?: string;
        table_schema: string;
    }>;
    functions: Array<{
        function_name: string;
        routine_type: string;
        data_type?: string;
        routine_definition?: string;
    }>;
    procedures: Array<{
        procedure_name: string;
        routine_type: string;
        routine_definition?: string;
    }>;
}
export declare abstract class QueryStrategy {
    abstract execute(client: PoolClient, query: string, params: any[], options: QueryOptions): Promise<QueryResult>;
    protected getDataTypeName(dataTypeID: number): string;
    protected formatExecutionTime(startTime: number): number;
}
export declare class SelectQueryStrategy extends QueryStrategy {
    execute(client: PoolClient, query: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
}
export declare class ModifyQueryStrategy extends QueryStrategy {
    execute(client: PoolClient, query: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
}
export declare class ProcedureQueryStrategy extends QueryStrategy {
    execute(client: PoolClient, query: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
}
export declare class QueryExecutor {
    private connectionManager;
    private queryCache;
    private readonly cacheTTL;
    constructor(connectionManager: ConnectionManager);
    executeQuery(connectionId: string, query: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
    executeProcedure(connectionId: string, procedureName: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
    executeFunction(connectionId: string, functionName: string, params?: any[], options?: QueryOptions): Promise<QueryResult>;
    getViewData(connectionId: string, viewName: string, limit?: number, options?: QueryOptions): Promise<QueryResult>;
    getTableData(connectionId: string, tableName: string, limit?: number, offset?: number, orderBy?: string, options?: QueryOptions): Promise<QueryResult>;
    private validateAndCleanQuery;
    private detectQueryType;
    private getDataTypeName;
    private shouldUseCache;
    private getCachedResult;
    private cacheResult;
    private generateCacheKey;
    private cleanupCache;
    /**
     * Get query execution statistics
     */
    getStatistics(): object;
    /**
     * Clear query cache
     */
    clearCache(): void;
    /**
     * Analyze query complexity (basic implementation)
     */
    analyzeQuery(query: string): object;
}
export default QueryExecutor;
//# sourceMappingURL=QueryExecutor.d.ts.map