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

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

/**
 * CBD Universal SQL Engine
 * Full SQL query processor with PostgreSQL compatibility
 *
 * Phase 1: Core SQL functionality with ACID guarantees and wire protocol compatibility
 */
import { EventEmitter } from 'events';
import { QueryContext, QueryResult } from './UniversalDataModel.js';
import { UniversalStorageEngine } from './UniversalStorageEngine.js';
/**
 * SQL query types
 */
export type SQLQueryType = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'CREATE' | 'DROP' | 'ALTER';
/**
 * SQL query result
 */
export interface SQLQueryResult extends QueryResult {
    columns: Array<{
        name: string;
        type: string;
        nullable: boolean;
    }>;
    rowCount: number;
    affectedRows?: number;
}
/**
 * Table schema definition
 */
export interface TableSchema {
    name: string;
    schema: string;
    columns: Array<{
        name: string;
        type: string;
        nullable: boolean;
        defaultValue?: any;
        primaryKey?: boolean;
        autoIncrement?: boolean;
        unique?: boolean;
    }>;
    primaryKey: string[];
    foreignKeys: Array<{
        columns: string[];
        referencedTable: string;
        referencedColumns: string[];
        onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
        onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
    }>;
    indexes: Array<{
        name: string;
        columns: string[];
        unique: boolean;
        type?: 'btree' | 'hash' | 'gin' | 'gist';
    }>;
    constraints: Array<{
        name: string;
        type: 'CHECK' | 'UNIQUE' | 'NOT NULL';
        expression: string;
    }>;
}
/**
 * Transaction context
 */
export interface Transaction {
    id: string;
    isolationLevel: 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE';
    status: 'ACTIVE' | 'COMMITTED' | 'ABORTED';
    startTime: Date;
    readSet: Set<string>;
    writeSet: Set<string>;
    locks: Map<string, 'SHARED' | 'EXCLUSIVE'>;
}
/**
 * Universal SQL Engine - PostgreSQL-compatible SQL processor
 */
export declare class UniversalSQLEngine extends EventEmitter {
    private storageEngine;
    private schemas;
    private activeTransactions;
    private lockManager;
    private queryCache;
    private statistics;
    constructor(storageEngine: UniversalStorageEngine);
    /**
     * Execute SQL query with full ACID compliance
     */
    executeSQL(sql: string, parameters?: any[], context?: QueryContext & {
        transactionId?: string;
    }): Promise<SQLQueryResult>;
    /**
     * Begin transaction with specified isolation level
     */
    beginTransaction(isolationLevel?: Transaction['isolationLevel']): Promise<string>;
    /**
     * Commit transaction
     */
    commitTransaction(transactionId: string): Promise<void>;
    /**
     * Rollback transaction
     */
    rollbackTransaction(transactionId: string): Promise<void>;
    /**
     * Create table with full schema support
     */
    createTable(schemaName: string, tableName: string, columns: TableSchema['columns'], options?: {
        primaryKey?: string[];
        foreignKeys?: TableSchema['foreignKeys'];
        indexes?: TableSchema['indexes'];
        constraints?: TableSchema['constraints'];
    }): Promise<void>;
    /**
     * Drop table
     */
    dropTable(schemaName: string, tableName: string, cascade?: boolean): Promise<void>;
    /**
     * Get table schema
     */
    getTableSchema(schemaName: string, tableName: string): TableSchema | null;
    /**
     * List all tables in schema
     */
    getTables(schemaName?: string): string[];
    /**
     * Get SQL engine statistics
     */
    getStatistics(): SQLEngineStats;
    private parseSQL;
    private validateQuery;
    private executeSelect;
    private executeInsert;
    private executeUpdate;
    private executeDelete;
    private executeCreate;
    private executeDrop;
    private executeAlter;
    private hashQuery;
    private extractTables;
    private extractColumns;
    private extractConditions;
    private extractInsertValues;
    private queryTableRecords;
    private validateTableSchema;
    private createTableIndexes;
    private checkForeignKeyReferences;
    private deleteAllTableRecords;
    private validateTransactionCommit;
    private undoTransactionChanges;
    private createInitialStats;
    private updateStatistics;
}
export interface ParsedQuery {
    type: SQLQueryType;
    sql: string;
    parameters: any[];
    tables: string[];
    columns: string[];
    conditions: any[];
}
interface SQLEngineStats {
    queriesExecuted: number;
    selectQueries: number;
    insertQueries: number;
    updateQueries: number;
    deleteQueries: number;
    ddlQueries: number;
    averageQueryTime: number;
    cacheHitRate: number;
    activeTransactions: number;
    committedTransactions: number;
    rolledBackTransactions: number;
    errorCount: number;
    tablesCreated: number;
    totalRows: number;
}
export {};
//# sourceMappingURL=UniversalSQLEngine.d.ts.map